🥥 🤱🏽 👩🏽‍🔧 स्टीम फाइलें भाग 1 - जीसीएफ / एनसीएफ 😡 💃🏼 🔮

जैसा कि पिछले लेख में वादा किया गया था , मैं स्टीम अवसंरचना के उस हिस्से के बारे में लेख प्रकाशित करना शुरू कर रहा हूं जो एंटी-स्टीम समुदाय रिवर्स इंजीनियरिंग और लंबे समय तक विचार-मंथन द्वारा खोल सकता है।

हाल तक तक, जीसीएफ फाइलें वैलव द्वारा जारी किए गए सभी खेलों के लिए मानक थे, और अन्य सभी के लिए एनसीएफ। अपने आप से, ये फाइलें सुरक्षा के कई स्तरों के साथ एक फ़ाइल सिस्टम छवि का प्रतिनिधित्व करती हैं। NCF और GCF के बीच अंतर यह है कि पूर्व में केवल हेडर होते हैं, और उनसे संबंधित फाइलें एक अलग निर्देशिका ( <स्टीम निर्देशिका> / SteamApps / आम / <खेल नाम> ) में स्थित होती हैं। इसलिए, मैं GCF का वर्णन करूंगा, और बाद में NCF की सभी विशेषताओं को दूंगा।

इस लेख में, मैं इन फ़ाइलों की संरचना का विस्तार से विश्लेषण करूंगा और अपने पुस्तकालय के उदाहरण का उपयोग करके उनके साथ काम करूंगा (यह लेख का एक लिंक लेख के अंत में है)। शुरुआत काफी उबाऊ होगी - संरचनाओं और उनके क्षेत्रों के उद्देश्य का वर्णन। सबसे "स्वादिष्ट" उनके बाद होगा ...

यहां सभी कोड स्टीम लाइब्रेरी के रिवर्स इंजीनियरिंग का परिणाम है। फ़ाइल प्रारूप के बारे में अधिकांश जानकारी खुले स्रोतों से प्राप्त की गई थी, लेकिन मैंने इसे थोड़ा पूरक किया और कैश फ़ाइलों के साथ काम को अनुकूलित किया (यहां तक कि उस समय सबसे लोकप्रिय HLLIB पुस्तकालय के साथ तुलना की गई)।

सामान्य फ़ाइल संरचना

फ़ाइल को तार्किक रूप से 2 भागों में विभाजित किया जाता है - हेडर और स्वयं सामग्री। सामग्री को ब्लॉकों में विभाजित किया गया है, जो बदले में 8kB सेक्टरों में विभाजित हैं, जिनमें से संबंधित कुछ फाइलें और उनके अनुक्रम हेडर में वर्णित हैं। सभी हेडर में फ़ील्ड होते हैं जो चार-बाइट पूर्णांक होते हैं (अपवाद फ़ाइल नाम और निर्देशिका की सूची के लिए जिम्मेदार भाग है)।

हेडर में निम्नलिखित संरचनाएँ होती हैं:

FileHeader
BlockAllocationTableHeader
BlockAllocationTable []
FileAllocationTableHeader
FileAllocationTable []
ManifestHeader
प्रकट []
फ़ाइल नाम
HashTableKeys []
HashTableIndices []
न्यूनतम फ़ुटप्रिंट्स []
UserConfig []
ManifestMapHeader
घोषणापत्र []
ChecksumDataContainer
FileIdChecksumTableHeader
FileIdChecksums []
चेकसम []
चेकसम हस्ताक्षर
LatestApplicationVersion
DataHeader

पहली चीज जो आपकी आंख को पकड़ती है वह है चेकसमइनग्नेचर , जो हेडर भाग का एक एन्क्रिप्टेड हैश है जो फाइलों के चेकसम के लिए जिम्मेदार है।

इन सभी शीर्षकों और उनके क्षेत्रों के उद्देश्य पर बाद में चर्चा की जाएगी।

उन लोगों के लिए जो बहुत ध्यान से नहीं पढ़ते हैं, मैं आपको याद दिलाता हूं कि लगभग सभी हेडर के सभी फ़ील्ड चार-बाइट पूर्णांक (सी ++ में uint32_t ) हैं, जब तक कि अन्यथा निर्दिष्ट न हो।

FileHeader

नाम के आधार पर, यह संपूर्ण फ़ाइल का शीर्षलेख है और इसमें निम्नलिखित फ़ील्ड शामिल हैं:

HeaderVersion
CacheType
FormatVersion
ApplicationID
ApplicationVersion
IsMounted
Dummy0
fILESIZE
ClusterSize
ClusterCount
checksum

HeaderVersion - हमेशा 0x00000001, इस हेडर के संस्करण को दर्शाता है।

CacheType - GCF के लिए 0x00000001 और NCF के लिए 0x00000002।

FormatVersion - शेष हेडर के संरचना संस्करण को इंगित करता है। नवीनतम संस्करण 6. है यह बाद में वर्णित किया जाएगा।

ApplicationID - फ़ाइल पहचानकर्ता (AppID)।

ApplicationVersion फ़ाइल की सामग्री का संस्करण है। अद्यतनों की आवश्यकता को नियंत्रित करने के लिए कार्य करता है।

यदि फ़ाइल वर्तमान में किसी अन्य अनुप्रयोग द्वारा आरोहित है तो IsMounted - में 0x00000001 सम्‍मिलित है । वर्तमान में उपयोग नहीं किया जाता है, इसलिए हमेशा 0x00000000।

डमी 0 एक संरेखण क्षेत्र है जिसमें 0x00000000 होता है।

FileSize कुल फ़ाइल आकार है। यदि यह 4 जीबी से अधिक है, तो इस फ़ील्ड में अंतर <फ़ाइल आकार> -ffffffff है , और फ़ाइल का आकार स्वयं पर आधारित है

डेटा ब्लॉक का आकार और मात्रा।

ClusterSize - सामग्री में डेटा ब्लॉक का आकार। GCF के लिए, इसमें 0x00002000 और NCF, 0x00000000 शामिल हैं।

ClusterCount - सामग्री में डेटा ब्लॉक की संख्या।

चेकसम हेडर का चेकसम है। इसकी गणना निम्नलिखित कार्य द्वारा की जाती है:

UINT32 HeaderChecksum(UINT8 *lpData, int Size) { UINT32 Checksum = 0; for (int i=0 ; i<Size ; i++) Checksum += *(lpData++); return Checksum; }

पहला पैरामीटर पॉइंटर को संरचना में भेजता है, और दूसरा - इसका आकार, चेकसम फील्ड के अपवाद के साथ (जो कि 4 से कम है)।

BlockAllocationTableHeader

ब्लॉक तालिका का विवरण शामिल है (सेक्टर नहीं!):

BlockCount
BlocksUsed
LastUsedBlock
Dummy0
Dummy1
Dummy2
Dummy3
checksum

ब्लॉककाउंट - फाइल में कुल ब्लॉक होते हैं।

BlocksUsed - प्रयुक्त ब्लॉकों की संख्या। हमेशा ब्लॉक की कुल संख्या से कम। यदि यह आ रहा है, तो कुल मात्रा का मूल्य बढ़ जाता है, जो बाद के सभी हेडर के पुनर्निर्माण और हेडर के लिए स्थान खाली करने के लिए फ़ाइल के अंत में पहला डेटा सेक्टर स्थानांतरित करने का कारण बनता है।

LastUsedBlock - अंतिम प्रयुक्त ब्लॉक का सूचकांक।

डमी 0, डमी 1, डमी 2, डमी 2 - अलाइनमेंट फ़ील्ड में 0x00000000 होते हैं।

चेकसम हेडर का चेकसम है। पिछले सभी क्षेत्रों का योग सम्‍मिलित है।

BlockAllocationTable

यह BlockAllocationTableEntry संरचनाओं का एक सरणी है, जिसकी संख्या ब्लॉक की कुल संख्या के बराबर है ( BlockAllocationTableHeader.BlockCount ):

uint16_t झंडे
uint16_t डमी 0
FileDataOffset
FileDataSize
FirstClusterIndex
NextBlockIndex
PreviousBlockIndex
ManifestIndex

झंडे - ब्लॉक के बिट झंडे शामिल हैं। संभव मास्क:

0x8000 - ब्लॉक उपयोग में है;
0x4000 - फ़ाइल की एक स्थानीय प्रतिलिपि पूर्वता लेती है;
0x0004 - ब्लॉक एन्क्रिप्टेड है;
0x0002 - ब्लॉक एन्क्रिप्टेड और संपीड़ित है;
0x0001 - ब्लॉक में कुछ कच्चे डेटा (RAW) हैं।

डमी 0 संरेखण क्षेत्र, 0x0000 शामिल हैं।

FileDataOffset में फ़ाइल के सापेक्ष इस ब्लॉक की भरपाई होती है।

FileDataSize - इस ब्लॉक में संग्रहीत फ़ाइल के टुकड़े का आकार।

FirstClusterIndex - क्लस्टर तालिका में पहले क्लस्टर का सूचकांक।

NextBlockIndex - अगले ब्लॉक का सूचकांक। इसमें BlockAllocationTableHeader का मान समाहित है। अगर यह फ़ाइल के लिए श्रृंखला का अंतिम ब्लॉक है तो ब्लॉककाउंट करें।

पिछलाब्लॉकइंडेक्स - श्रृंखला में पिछले ब्लॉक का सूचकांक शामिल है। यदि यह पहला है, तो इसमें BlockAllocationTableHeader का मान है । BlockCount।

ManifestIndex - इस ब्लॉक के लिए प्रकट सूचकांक।

तालिका का सूचकांक घोषणापत्र सूची से ब्लॉक नंबर है।

FileAllocationTableHeader

सेक्टर तालिका शीर्ष लेख:

ClusterCount
FirstUnusedEntry
IsLongTerminator
checksum

ClusterCount - क्षेत्रों की संख्या शामिल है। FileHeader.ClusterCount के बराबर मान रखता है ।

FirstUnusedEntry - पहले अप्रयुक्त क्षेत्र का सूचकांक।

IsLongTerminator - एक मान को परिभाषित करता है जो सेक्टर श्रृंखला के अंत का एक संकेतक है। यदि इसमें 0x00000000 शामिल हैं, तो टर्मिनेटर 0x0000FFFF है, अन्यथा - 0xFFFFFFFF।

चेकसम हेडर का चेकसम है। BlockAllocationTableHeader की तरह, पिछले शीर्ष लेख फ़ील्ड का योग है।

FileAllocationTable

FileAllocationTableHeader.ClusterCount प्रकार uint32_t की प्रविष्टियों वाली एक सेक्टर तालिका। प्रत्येक सेल में चेन या टर्मिनेटर मान में अगले क्लस्टर का इंडेक्स होता है (चेन में अंतिम होने पर FileAllocationTableHeader घोषणा देखें।

सूची का सूचकांक क्षेत्र संख्या है।

ManifestHeader

मेनिफेस्ट टेबल का विवरण शामिल है:

HeaderVersion
ApplicationID
ApplicationVersion
NodeCount
FileCount
CompressionBlockSize
BinarySize
NameSize
HashTableKeyCount
NumOfMinimumFootprintFiles
NumOfUserConfigFiles
bitmask
अंगुली की छाप
checksum

हेडरवर्जन हेडर का संस्करण है। 0x00000004 शामिल हैं।

ApplicationID - फ़ाइल पहचानकर्ता। FileHeader.ApplicationID के बराबर है ।

ApplicationVersion फ़ाइल की सामग्री का संस्करण है। FileHeader.ApplicationVersion के बराबर है ।

NodeCount - प्रकट तत्वों की संख्या।

FileCount - प्रकट में घोषित फ़ाइलों की संख्या (और कैश में निहित)।

CompressionBlockSize - एक संपीड़ित ब्लॉक का अधिकतम आकार (इसका असम्पीडित डेटा)।

बाइनरीसाइज़ - प्रकट आकार (इस संरचना सहित)।

NameSize - तत्वों (बाइट्स) के नाम वाले डेटा ब्लॉक का आकार।

HashTableKeyCount - हैश तालिका में मानों की संख्या।

NumOfMinimumFootprintFiles - एप्लिकेशन को चलाने के लिए न्यूनतम फ़ाइलों की संख्या आवश्यक है (जिसे डिस्क पर अनज़िप किया जाना चाहिए)।

NumOfUserConfigFiles - उपयोगकर्ता कॉन्फ़िगरेशन फ़ाइलों की संख्या। यदि यह फ़ाइल डिस्क पर है, तो खेल शुरू होने पर इसे अधिलेखित नहीं किया जाता है और इसकी उच्च प्राथमिकता होती है।

बिटमास्क - में बिटमास्क होते हैं। फ़ाइलों के सार्वजनिक संस्करणों में, इसमें हमेशा 0x00000000 शामिल होते हैं।

फ़िंगरप्रिंट एक अद्वितीय संख्या है जो हर बार प्रकट होने पर यादृच्छिक रूप से उत्पन्न होती है।

चेकसम - चेकसम। यह एडलर 32 एल्गोरिथ्म का उपयोग करके गणना की जाती है। गणना एल्गोरिथ्म हेडर के विवरण के बाद दिया जाएगा।

प्रकट

एक पेड़ जिसमें कैश की सभी फाइलों का विवरण होता है। तालिका का आकार घोषणापत्र के मान के बराबर है। NodeCount । तालिका के सभी तत्वों को निम्नलिखित संरचनाओं द्वारा दर्शाया गया है:

NameOffset
CountOrSize
FileId
गुण
ParentIndex
NextIndex
ChildIndex

NameOffset - संबंधित डेटा ब्लॉक में तत्व के नाम की ऑफसेट।

CountOrSize - तत्व का आकार। निर्देशिकाओं के लिए, यह बच्चों की संख्या के बराबर है, और फ़ाइलों के लिए, सीधे फ़ाइल के आकार (या इस प्रकट द्वारा वर्णित फ़ाइल का हिस्सा) के लिए।

FileId - फ़ाइल पहचानकर्ता। बड़ी फ़ाइलों के लिए कई मैनिफ़ेस्ट लिंक करने और चेकसम सूची खोजने के लिए कार्य करता है।

विशेषताएँ - फ़ाइल विशेषता बिट फ़ील्ड। संभावित मान (पुष्टि से):

0x00004000 - नोड एक फ़ाइल है;
0x00000100 - एन्क्रिप्टेड फ़ाइल;
0x00000001 - कॉन्फ़िगरेशन फ़ाइल। स्थानीय प्रति को अधिलेखित नहीं किया गया है।

ParentIndex मूल तत्व का सूचकांक है। जड़ तत्व के लिए 0xFFFFFFFF है।

NextIndex - वर्तमान पेड़ के स्तर पर अगले तत्व का सूचकांक।

चाइल्डइंडेक्स पहले बच्चे का सूचकांक है।

यदि NextIndex और ChildIndex के लिए कोई तत्व नहीं हैं, तो उनका मान 0x00000000 होता है।

एक पेड़ में कम से कम एक तत्व होना चाहिए - जड़।

ट्री आइटम वाली सूची का सूचकांक आइटम नंबर है (बाद में उपयोग किया गया)

फ़ाइल नाम

आकार का एक डेटा ब्लॉक ManifestHeader.NameSize बाइट्स। इसमें नल-टर्मिनेटेड स्ट्रिंग्स शामिल हैं, जो कि प्रकट पेड़ में वर्णित तत्वों के नाम हैं। अनिवार्य पहले, जड़ तत्व की उपस्थिति है - एक खाली स्ट्रिंग। तत्व नामों की भरपाई मूल्य मेनिफेस्ट [] के नाम से निर्दिष्ट है । NameOffset

HashTableKeys

तत्व नामों की हैश तालिका समाहित करता है। HashTableIndices के लिए इंडेक्स वैल्यूज़ शामिल हैं, जो कि लोअरकेस स्ट्रिंग्स के लिए जेनकिंस हैश फंक्शन लुकअप 2 से प्राप्त सूचकांकों पर वितरित किए गए हैं। तत्वों की खोज के विवरण में अधिक चर्चा की जाएगी।

HashTableIndices

पिछली तालिका के मानों द्वारा संदर्भित तत्वों के अनुक्रमित की एक तालिका शामिल है। तत्वों की संख्या ManifestHeader.NodeCount है ।

MinimumFootprints

मैनिफेस्ट में आइटम नंबर की एक सूची शामिल है जिसे एप्लिकेशन शुरू होने पर अनपैक किया जाना चाहिए।

UserConfigs

मैनिफ़ेस्ट में आइटम नंबर सूचीबद्ध करता है, जो उपयोगकर्ता कॉन्फ़िगरेशन फ़ाइलें हैं।

ManifestMapHeader

मैनीफेस्ट मैप हैडर:

HeaderVersion
Dummy0

हेडरवर्जन हेडर का संस्करण है। बराबर 0x00000001।

डमी 0 एक संरेखण मूल्य है। 0x00000000 शामिल हैं।

ManifestMap

प्रत्येक तत्व के लिए पहले ब्लॉक ( BlockAllocationTable संरचना) के लिंक की एक तालिका शामिल है। एक तत्व सूचकांक प्रकट पेड़ में एक तत्व की संख्या है। निर्देशिकाओं और फ़ाइलों को कैश में संग्रहीत नहीं किया जाता है (शून्य आकार या NCF के लिए), इसमें ब्लॉकअक्लोकेशनटेबल हैडर.ब्लॉकाउंट के बराबर मूल्य होता है।

ChecksumDataContainer

कंटेनर का हेडर जो चेकसम को स्टोर करता है:

HeaderVersion
ChecksumSize

हेडरवर्जन हेडर का संस्करण है। बराबर 0x00000001।

ChecksumSize - कंटेनर का आकार। इसकी गणना निम्न संरचना से की जाती है और इसमें नवीनतमएप्लीकेशन वर्जन सम्मिलित है।

FileIdChecksumTableHeader

चेकसम इंडेक्स टेबल का शीर्षक:

FormatCode
Dummy0
FileIdCount
ChecksumCount

फ़ॉर्मेटकोड एक स्थिर है। बराबर 0x14893721।

Dummy0 एक समतल क्षेत्र है। 0x00000001 का मान समाहित करता है।

FileIdCount - तत्व-प्रथम-हैश तालिका में तत्वों की संख्या।

चेकसममाउंट - चेकसम सूची में तत्वों की संख्या।

FileIdChecksums

चेकसम सूची में फ़ाइलों को जोड़ने वाली एक तालिका:

ChecksumCount
FirstChecksumIndex

ChecksumCount - इस तत्व के लिए सूची में चेकसम की संख्या।

FirstChecksumIndex - सूची में पहले चेकसम का सूचकांक।

इंडेक्स मैनिफेस्ट [] मान है।

चेकसम

चेकसम की सूची। इसमें लगातार उपखंड शामिल हैं, जिनमें से पहला तत्व FileIdChecksums [] FirstChecksumIndex के मान से संदर्भित है।

मानों की गणना निम्न एल्गोरिथम का उपयोग करके की जाती है:

 UINT32 Checksum(UINT8 *lpData, UINT32 uiSize) { return (adler32(0, lpData, uiSize) ^ crc32(0, lpData, uiSize)); }

चेकसम हस्ताक्षर

चेकसम ब्लॉक के हस्ताक्षर। SHA-1 एल्गोरिथ्म द्वारा गणना की गई और RSASSA-PKCS1-v1_5 एल्गोरिथ्म द्वारा गणना की गई चेकसम ब्लॉक के लिए हैश मान होता है ।

LatestApplicationVersion

इस फ़ील्ड में चेकसम ब्लॉक का संस्करण है। प्रत्येक सामग्री अपडेट के बाद करंट को अपडेट करना।

DataHeader

कैश में डेटा के भौतिक स्थान का वर्णन शीर्षक:

ClusterCount
ClusterSize
FirstClusterOffset
ClustersUsed
checksum

ClusterCount - सेक्टरों की संख्या। मान FileHeader.ClusterCount फ़ील्ड के बराबर है।

क्लस्टर आकार - क्षेत्र का आकार। मान FileHeader.ClusterSize फ़ील्ड के बराबर है।

FirstClusterOffset - फ़ाइल की शुरुआत के सापेक्ष पहले क्षेत्र की ऑफसेट।

क्लस्टर्सयूल्ड - प्रयुक्त क्षेत्रों की संख्या।

चेकसम हेडर का चेकसम है। पूर्ववर्ती हेडर फ़ील्ड के योग के बराबर।

सामग्री को अपडेट करने के बाद, उपयोग किए जाने वाले क्षेत्रों की संख्या घट सकती है। ऐसे मामलों में, मुक्त किए गए क्षेत्रों को भविष्य के अपडेट के लिए स्थान आरक्षित करने के लिए फ़ाइल के अंत में स्थानांतरित किया गया था।

एल्गोरिदम

अंत में, सबसे दिलचस्प की बारी आई - कोड का सबसे दिलचस्प उदाहरण जो इन संरचनाओं के साथ विस्तृत स्पष्टीकरण के साथ काम करता है। पूर्ण स्रोत पैकेज मेरे भंडार पर पाया जा सकता है ।

फ़ाइल का आकार गणना

ज्यादातर मामलों में, फ़ाइल का आकार मैनिफेस्ट [] के मान के बराबर है । CountOrSize फ़ील्ड । लेकिन 4GB से बड़ी फ़ाइलों के लिए यह तरीका उपयुक्त नहीं है। वाल्व प्रोग्रामर्स ने इसे इस तरह से दरकिनार किया: 2 जीबी से बड़ी फ़ाइलों के लिए, इस फ़ील्ड के उच्च बिट को "1" पर सेट करें और सूची में शेष क्षेत्रों के समान मूल्यों के साथ एक और (या कई) तत्वों को शुरू करें, एक प्रकार की श्रृंखला प्राप्त करें। मैनिफेस्ट [] के मूल्य को सारांशित करना। इस श्रृंखला से फ़ील्ड्स की गणना करें, हम कुल फ़ाइल आकार की गणना करते हैं।

फाइल साइज काउंटिंग कोड

 UINT64 CGCFFile::GetFileSize(UINT32 Item) { UINT64 res = lpManifest[Item].CountOrSize & 0x7FFFFFFF; if ((lpManifest[Item].CountOrSize & 0x80000000) != 0) { for (UINT32 i=0 ; i<pManifestHeader->NodeCount ; i++) { ManifestNode *MN = &lpManifest[Item]; if (((MN->Attributes & 0x00004000) != 0) && (MN->ParentIndex == 0xFFFFFFFF) && (MN->NextIndex == 0xFFFFFFFF) && (MN->ChildIndex == 0xFFFFFFFF) && (MN->FileId == lpManifest[Item].FileId)) { res += MN->CountOrSize << 31; break; } } } return res; }

यहाँ मैंने अपने कानों से एक छोटा सा "फेंट" बनाया, यह मानते हुए कि 4GB से बड़ी फाइलें अभी भी कैश का हिस्सा नहीं होंगी ...

नाम से एक आइटम के लिए खोजें

उदाहरण के लिए, हमें "hl2 / map / background_01.bsp" नामक एक फ़ाइल खोजने की आवश्यकता है। हमारे द्वारा संग्रहीत सभी नाम एक पेड़ के रूप में संग्रहीत हैं, इसलिए हमें एक विभाजक (इस मामले में, "/") से जुड़े तत्वों में पथ को तोड़ना होगा। फिर हम मूल तत्व के वंशज से "hl2" नाम के तत्व की तलाश करते हैं। उसके पास "मैप्स" नाम के साथ एक तत्व है, और केवल "बैकग्राउंड_01.स्पून" नाम के साथ एक तत्व है। यह रास्ता सबसे स्पष्ट है, लेकिन बहुत धीमा है - स्ट्रिंग्स की एक बाइट तुलना है, और यहां तक कि एक पेड़ का दौरा भी है। सरासर खर्च

इस प्रक्रिया को तेज करने के लिए हैश टेबल हेडर में हैं।

किसी हैश का उपयोग करके किसी आइटम के लिए खोजें

सी ++

 UINT32 CGCFFile::GetItem(char *Item) { int DelimiterPos = -1; for (UINT32 i=0 ; i<strlen(Item) ; i++) if (Item[i] == '\\') DelimiterPos = i; char *FileName = &Item[++DelimiterPos]; UINT32 Hash = jenkinsLookupHash2((UINT8*)FileName, strlen(FileName), 1), HashIdx = Hash % pManifestHeader->HashTableKeyCount, HashFileIdx = lpHashTableKeys[HashIdx]; if (HashFileIdx == CACHE_INVALID_ITEM) if (strcmp(LowerCase(Item), Item) != 0) { Hash = jenkinsLookupHash2((UINT8*)LowerCase(Item), strlen(FileName), 1); HashIdx = Hash % pManifestHeader->HashTableKeyCount; HashFileIdx = lpHashTableKeys[HashIdx]; } if (HashFileIdx == CACHE_INVALID_ITEM) return CACHE_INVALID_ITEM; HashFileIdx -= pManifestHeader->HashTableKeyCount; while (true) { UINT32 Value = this->lpHashTableIndices[HashFileIdx]; UINT32 FileID = Value & 0x7FFFFFFF; if (strcmp(GetItemPath(FileID), Item) == 0) return FileID; if ((Value & 0x80000000) == 0x80000000) break; HashFileIdx++; } return CACHE_INVALID_ITEM; }

डेल्फी

 function TGCFFile.GetItemByPath(Path: string): integer; var end_block: boolean; Hash, HashIdx, HashValue: ulong; FileID, HashFileIdx: integer; PathEx: AnsiString; begin result:=-1; {$IFDEF UNICODE} PathEx:=Wide2Ansi(ExtractFileName(Path)); {$ELSE} PathEx:=ExtractFileName(Path); {$ENDIF} Hash:=jenkinsLookupHash2(@PathEx[1], Length(PathEx), 1); HashIdx:=Hash mod fManifestHeader.HashTableKeyCount; HashFileIdx:=lpHashTableKeys[HashIdx]; if HashFileIdx=-1 then begin if (LowerCase(Path)<>Path) then begin {$IFDEF UNICODE} Hash:=jenkinsLookupHash2(@LowerCaseAnsi(PathEx)[1], Length(PathEx), 1); {$ELSE} Hash:=jenkinsLookupHash2(@LowerCase(PathEx)[1], Length(PathEx), 1); {$ENDIF} HashIdx:=Hash mod fManifestHeader.HashTableKeyCount; HashFileIdx:=lpHashTableKeys[HashIdx]; if HashFileIdx=-1 then Exit; end; end; dec(HashFileIdx, fManifestHeader.HashTableKeyCount); repeat HashValue:=lpHashTableIndices[HashFileIdx]; FileID:=HashValue and $7FFFFFFF; end_block:= (HashValue and $80000000 = $80000000); if CompareStr(ItemPath[FileID], Path)=0 then begin result:=FileID; Exit; end; inc(HashFileIdx); until end_block; if (result=-1) and (LowerCase(Path)<>Path) then result:=GetItemByPath(LowerCase(Path)); end;

जैसा कि आप कोड से देख सकते हैं, पूरे रास्ते से फाइल तक हम केवल इसका नाम लेते हैं और इसके लिए हैश की गणना करते हैं। हम परिणाम के शेष पूर्णांक विभाजन को मान ManifestHeader.ashTableKeyCount द्वारा लेते हैं - यह HashTableKeys सूची में प्रविष्टि की संख्या होगी जिसमें 0xffffffff (यदि ऐसा कोई तत्व नहीं है) या मान X + ManifestHeader.HashTableKeyCount है । इसके आधार पर, हम X की गणना करते हैं, जो कि HashTableIndices सूची में तत्व की संख्या है जिसमें से पाया जाने वाला तत्व पाया जा सकता है। इस सूची के मान खोजे जाने वाले आइटम को इंगित करते हैं, जिसका नाम क्वेरी में तुलना की जाती है। यदि यह मेल नहीं खाता है, तो हम सूची के अगले तत्व को लेते हैं और तब तक दोहराते हैं जब तक कि तत्व संख्या का सबसे महत्वपूर्ण बिट "0" न हो।

मैं समझता हूं कि यह भ्रमित हो गया, लेकिन यह कैसे काम करता है ... इस तरह के भ्रम के लिए वाल्व प्रोग्रामर को दोष दें।

यह विधि पेड़ में प्रत्यक्ष खोज से बहुत बेहतर है - खेल शुरू करते समय प्रदर्शन की तुलना स्टीम.डेल स्व-लिखित लाइब्रेरी-एमुलेटर लाइब्रेरी के साथ की गई थी, जिस पर अभी भी चर्चा की जाएगी।

किसी तत्व को पूर्ण पथ मिलना

यह क्रिया पिछले एक पर वापस आ गई है - उस तत्व की संख्या से, जिसे आपको पेड़ से जड़ तत्व तक जाने की ज़रूरत है और फ़ाइल में पथ प्राप्त करना है।

फ़ाइल पथ प्राप्त करना

सी ++

 char *CGCFFile::GetItemPath(UINT32 Item) { size_t len = strlen(&lpNames[lpManifest[Item].NameOffset]); UINT32 Idx = lpManifest[Item].ParentIndex; while (Idx != CACHE_INVALID_ITEM) { len += strlen(&lpNames[lpManifest[Idx].NameOffset]) + 1; Idx= lpManifest[Idx].ParentIndex; } len--; char *res = new char[len+1]; memset(res, 0, len+1); size_t l = strlen(&lpNames[lpManifest[Item].NameOffset]); memcpy(&res[len-l], &lpNames[lpManifest[Item].NameOffset], l); len -= strlen(&lpNames[lpManifest[Item].NameOffset]); res[--len] = '\\'; Item = lpManifest[Item].ParentIndex; while ((Item != CACHE_INVALID_ITEM) && (Item != 0)) { l = strlen(&lpNames[lpManifest[Item].NameOffset]); memcpy(&res[len-l], &lpNames[lpManifest[Item].NameOffset], l); len -= strlen(&lpNames[lpManifest[Item].NameOffset]); res[--len] = '\\'; Item = lpManifest[Item].ParentIndex; } return res; }

डेल्फी

 function TGCFFile.GetItemPath(Item: integer): string; var res: AnsiString; begin res:=pAnsiChar(@fNameTable[lpManifestNodes[Item].NameOffset+1]); Item:=lpManifestNodes[Item].ParentIndex; while (Item>-1) do begin res:=pAnsiChar(@fNameTable[lpManifestNodes[Item].NameOffset+1])+'\'+res; Item:=lpManifestNodes[Item].ParentIndex; end; Delete(res, 1, 1); {$IFDEF UNICODE} result:=Ansi2Wide(res); {$ELSE} result:=res; {$ENDIF} end;

डेल्फी के लिए कोड इस तथ्य के कारण बहुत छोटा है कि C ++ के लिए मैंने std :: string class का उपयोग नहीं किया - मुझे तब इसके बारे में पता नहीं था। इसके साथ, कोड बहुत कम होगा ...

धाराओं

संग्रह-जैसे फ़ाइल स्वरूपों (जिसमें अन्य फ़ाइलें हैं) के लिए लाइब्रेरी लिखते समय, मैं "स्ट्रीम-इन-स्ट्रीम" सिद्धांत का उपयोग करता हूं, जो आपको बिना संग्रह किए फ़ाइलों को एक संग्रह में खोलने की अनुमति देता है। उदाहरण के लिए, पुराने संस्करणों के कैश आधा-जीवन में। एक फ़ाइल pak0.pak थी , जो एक संग्रह है। नतीजतन, मैंने आधा जीवन खोला। जीसीएफ फ़ाइल , इसमें - pak0.pak । जिसमें, बदले में, मैं आवश्यक फाइलें पढ़ता हूं। और यह सब - मेमोरी में भी अनपैक किए बिना, सभी कार्यक्षमता को मैंने फाइल स्ट्रीम (WindowsAPI स्तर पर निम्न-स्तर) पर लिखे रैपर के माध्यम से कार्यान्वित किया है।

कैश में फ़ाइल खोलना

सी ++

 CStream *CGCFFile::OpenFile(char* FileName, UINT8 Mode) { UINT32 Item = GetItem(FileName); if (Item == CACHE_INVALID_ITEM) return NULL; if ((lpManifest[Item].Attributes & CACHE_FLAG_FILE) != CACHE_FLAG_FILE) return NULL; return OpenFile(Item, Mode); } CStream *CGCFFile::OpenFile(UINT32 Item, UINT8 Mode) { StreamData *Data = new StreamData(); memset(Data, 0, sizeof(StreamData)); Data->Handle = (handle_t)Item; Data->Package = this; Data->Size = this->GetItemSize(Item).Size; if (IsNCF) Data->FileStream = (CStream*)new CStream(MakeStr(CommonPath, GetItemPath(Item)), Mode==CACHE_OPEN_WRITE); else BuildClustersTable(Item, &Data->Sectors); return new CStream(pStreamMethods, Data); }

डेल्फी

 function TGCFFile.OpenFile(FileName: string; Access: byte): TStream; var Item: integer; begin result:=nil; Item:=ItemByPath[FileName]; if (Item=-1) then Exit; if ((lpManifestNodes[Item].Attributes and HL_GCF_FLAG_FILE<>HL_GCF_FLAG_FILE) or (ItemSize[Item].Size=0)) then Exit; result:=OpenFile(Item, Access); end; function TGCFFile.OpenFile(Item: integer; Access: byte): TStream; var res: TStream; begin res:=TStream.CreateStreamOnStream(@StreamMethods); res.Data.fHandle:=ulong(Item); res.Data.Package:=self; res.Data.fSize:=(res.Data.Package as TGCFFile).ItemSize[Item].Size; res.Data.fPosition:=0; if (IsNCF) then begin CommonPath:=IncludeTrailingPathDelimiter(CommonPath); case Access of ACCES_READ: begin res.Data.FileStream:=TStream.CreateReadFileStream(CommonPath+ItemPath[Item]); res.Methods.fSetSiz:=StreamOnStream_SetSizeNULL; res.Methods.fWrite:=StreamOnStream_WriteNULL; end; ACCES_WRITE: begin ForceDirectories(ExtractFilePath(CommonPath+ItemPath[Item])); res.Data.FileStream:=TStream.CreateWriteFileStream(CommonPath+ItemPath[Item]); end; ACCES_READWRITE: res.Data.FileStream:=TStream.CreateReadWriteFileStream(CommonPath+ItemPath[Item]); end; res.Data.FileStream.Seek(0, spBegin); end else GCF_BuildClustersTable(Item, @res.Data.SectorsTable); result:=res; end;

इस प्रकार, सामग्री के साथ काम बहुत सरल है - आप अनावश्यक इशारों के बिना फ़ाइलों को खोल सकते हैं और उनसे डेटा पढ़ सकते हैं।

चेकसम फ़ाइल निष्कर्षण

इस प्रक्रिया में, ऊपर वर्णित धाराएं सक्रिय रूप से उपयोग की जाती हैं - मैं बस एक निश्चित आकार के टुकड़ों में फ़ाइल पढ़ता हूं (चेकसम के लिए अधिकतम टुकड़ा आकार 32Kb है), उनके लिए चेकसम की गणना करें और हेडर में तालिका से मानों के साथ उनकी तुलना करें।

किसी फ़ाइल को उसके COP की जाँच के साथ निकालना

सी ++

 UINT64 CGCFFile::ExtractFile(UINT32 Item, char *Dest, bool IsValidation) { CStream *fileIn = this->OpenFile(Item, CACHE_OPEN_READ), *fileOut; if (fileIn == NULL) return 0; if (!IsValidation) { if (DirectoryExists(Dest)) Dest = MakeStr(IncludeTrailingPathDelimiter(Dest), GetItemName(Item)); fileOut = new CStream(Dest, true); if (fileOut->GetHandle() == INVALID_HANDLE_VALUE) return 0; fileOut->SetSize(GetItemSize(Item).Size); } UINT8 buf[CACHE_CHECKSUM_LENGTH]; UINT32 CheckSize = CACHE_CHECKSUM_LENGTH; UINT64 res = 0; while ((fileIn->Position()<fileIn->GetSize()) && (CheckSize == CACHE_CHECKSUM_LENGTH)) { if (Stop) break; UINT32 CheckIdx = lpFileIDChecksum[lpManifest[Item].FileId].FirstChecksumIndex + ((fileIn->Position() & 0xffffffffffff8000) >> 15); CheckSize = (UINT32)fileIn->Read(buf, CheckSize); UINT32 CheckFile = Checksum(buf, CheckSize), CheckFS = lpChecksum[CheckIdx]; if (CheckFile != CheckFS) { break; } else if (!IsValidation) { fileOut->Write(buf, CheckSize); } res += CheckSize; } delete fileIn; if (!IsValidation) delete fileOut; return res; }

डेल्फी

 function TGCFFile.ExtractFile(Item: integer; Dest: string; IsValidation: boolean = false): int64; var StreamF, StreamP: TStream; CheckSize, CheckFile, CheckFS, CheckIdx: uint32_t; buf: array of byte; Size: int64; begin result:=0; StreamP:=OpenFile(Item, ACCES_READ); if (StreamP=nil) then Exit; Size:=ItemSize[Item].Size; if Assigned(OnProgress) then OnProgress(ItemPath[Item], 0, Size, Data); if Assigned(OnProgressObj) then OnProgressObj(ItemPath[Item], 0, Size, Data); StreamF:=nil; if (not IsValidation) then begin if DirectoryExists(Dest) then Dest:=IncludeTrailingPathDelimiter(Dest)+ExtractFileName(ItemName[Item]); StreamF:=TStream.CreateWriteFileStream(Dest); StreamF.Size:=ItemSize[Item].Size; if StreamF.Handle=INVALID_HANDLE_VALUE then begin StreamF.Free; Exit; end; end; SetLength(buf, HL_GCF_CHECKSUM_LENGTH); CheckSize:=HL_GCF_CHECKSUM_LENGTH; while ((StreamP.Position<StreamP.Size) and (CheckSize=HL_GCF_CHECKSUM_LENGTH)) do begin CheckIdx:=lpFileIdChecksumTableEntries[lpManifestNodes[Item].FileId].FirstChecksumIndex+ ((StreamP.Position and $ffffffffffff8000) shr 15); CheckSize:=StreamP.Read(buf[0], HL_GCF_CHECKSUM_LENGTH); CheckFile:=Checksum(@buf[0], CheckSize); CheckFS:=lpChecksumEntries[CheckIdx]; if (CheckFile<>CheckFS) and (not IgnoreCheckError) then begin if Assigned(OnError) then OnError(GetItemPath(Item), ERROR_CHECKSUM, Data); if Assigned(OnErrorObj) then OnErrorObj(GetItemPath(Item), ERROR_CHECKSUM, Data); break; end else if (not IsValidation) then StreamF.Write(buf[0], CheckSize); inc(result, CheckSize); if Assigned(OnProgress) then OnProgress('', result, Size, Data); if Assigned(OnProgressObj) then OnProgressObj('', result, Size, Data); if Stop then break; end; SetLength(buf, 0); StreamP.Free; if (not IsValidation) then StreamF.Free; end;

डेल्फी के लिए कोड में काम की प्रगति को प्रदर्शित करने के लिए एक अतिरिक्त कोड है - ऑनप्रोग्रेड, ऑनप्रोएगऑनजैक कॉलबैक फ़ंक्शन।

फ़ाइल सामग्री को डिक्रिप्ट करें

चूंकि रिलीज़ से कुछ समय पहले ही कई गेम डाउनलोड किए जा सकते हैं, ऐसे मामलों में उनकी सामग्री पूरी तरह से या आंशिक रूप से एन्क्रिप्ट की गई है। खेल की रिहाई के साथ, इस सामग्री को डिक्रिप्ट करने के लिए एक कुंजी उपलब्ध हो जाती है, जिसे निम्नलिखित कोड के साथ किया जाता है:

फ़ाइल डिक्रिप्शन

सी ++

 UCHAR IV[16] = {0}; void DecryptFileChunk(char *buf, UINT32 size, char *key) { AES_KEY aes_key; AES_set_decrypt_key((UCHAR*)key, 128, &aes_key); AES_cbc_encrypt((UCHAR*)buf, (UCHAR*)buf, size, &aes_key, IV, false); } UINT64 CGCFFile::DecryptFile(UINT32 Item, char *key) { UINT64 res = 0; CStream *str = OpenFile(Item, CACHE_OPEN_READWRITE); if (str == NULL) return 0; char buf[CACHE_CHECKSUM_LENGTH], dec[CACHE_CHECKSUM_LENGTH]; UINT32 CheckSize = CACHE_CHECKSUM_LENGTH; INT32 CompSize, UncompSize, sz; while ((str->Position() < str->GetSize()) && (CheckSize == CACHE_CHECKSUM_LENGTH)) { UINT32 CheckIdx = lpFileIDChecksum[lpManifest[Item].FileId].FirstChecksumIndex + ((str->Position() & 0xffffffffffff8000) >> 15); INT32 CheckSize = (INT32)str->Read(buf, 8); memcpy(&CompSize, &buf[0], 4); memcpy(&UncompSize, &buf[4], 4); if (((UINT32)UncompSize > pManifestHeader->CompressionBlockSize) || (CompSize > UncompSize) || (UncompSize < -1) || (CompSize < -1)) { // Chunk is not compressed CheckSize = (UINT32)str->Read(&buf[8], CACHE_CHECKSUM_LENGTH-8); DecryptFileChunk(&buf[0], CheckSize, key); } else if (((UINT32)UncompSize <= pManifestHeader->CompressionBlockSize) && (CompSize <= UncompSize) && (UncompSize > -1) || (CompSize > -1)) { // Chunk is compressed CheckSize = (UINT32)str->Read(&buf[8], UncompSize-8); INT32 CheckFile = UncompSize; if (CompSize%16 == 0) sz = CompSize; else sz = CompSize + 16 - (CompSize%16); memcpy(dec, buf, sz); DecryptFileChunk(&dec[0], sz, key); uncompress((Bytef*)&buf[0], (uLongf*)&CheckFile, (Bytef*)&dec[0], sz); } str->Seek(-CheckSize, USE_SEEK_CURRENT); str->Write(&buf[0], CheckSize); UINT32 Check1 = Checksum((UINT8*)&buf[0], CheckSize), Check2 = lpChecksum[CheckIdx]; if (Check1 != Check2) break; res += CheckSize; } lpManifest[Item].Attributes = lpManifest[Item].Attributes & (!CACHE_FLAG_ENCRYPTED); return res; }

डेल्फी

 const IV: array[0..15] of byte = (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0); procedure DecryptFileChunk(buf: pByte; ChunkSize: integer; Key: Pointer); var AES: TCipher_Rijndael; src: array[0..HL_GCF_CHECKSUM_LENGTH-1] of byte; begin Move(buf^, src[0], HL_GCF_CHECKSUM_LENGTH); AES:=TCipher_Rijndael.Create(); AES.Init(Key^, 16, IV[0], 16); AES.Mode:=cmCFBx; AES.Decode(src[0], buf^, ChunkSize); AES.Free; end; function TGCFFile.DecryptFile(Item: integer; Key: Pointer): int64; var StreamP: TStream; CheckSize, CheckFile, CheckFS, CheckIdx, sz: uint32_t; buf: array of byte; dec: array[0..HL_GCF_CHECKSUM_LENGTH] of byte; CompSize, UncompSize: integer; Size: int64; begin result:=0; StreamP:=OpenFile(Item, ACCES_READWRITE); if (StreamP=nil) then Exit; Size:=ItemSize[Item].Size; if Assigned(OnProgress) then OnProgress(ItemName[Item], 0, Size, Data); if Assigned(OnProgressObj) then OnProgressObj(ItemName[Item], 0, Size, Data); SetLength(buf, HL_GCF_CHECKSUM_LENGTH); CheckSize:=HL_GCF_CHECKSUM_LENGTH; while ((StreamP.Position<StreamP.Size) and (CheckSize=HL_GCF_CHECKSUM_LENGTH)) do begin CheckIdx:=lpFileIdChecksumTableEntries[lpManifestNodes[Item].FileId].FirstChecksumIndex+ ((StreamP.Position and $ffffffffffff8000) shr 15); CheckSize:=StreamP.Read(buf[0], 8); Move(buf[0], CompSize, 4); Move(buf[4], UncompSize, 4); if (ulong(UncompSize)>fManifestHeader.CompressionBlockSize) or (CompSize>UncompSize) or (UncompSize<-1) or (CompSize<-1) then begin //Chunk is not compressed! CheckSize:=StreamP.Read(buf[8], HL_GCF_CHECKSUM_LENGTH-8); DecryptFileChunk(@buf[0], CheckSize, Key); end else if ((ulong(UncompSize)<=fManifestHeader.CompressionBlockSize) and (CompSize<=UncompSize)) and ((UncompSize>-1) and (CompSize>-1)) then begin CheckSize:=StreamP.Read(buf[8], UncompSize-8); CheckFile:=UncompSize; //Chunk is compressed! if (CompSize mod 16=0) then sz:=CompSize else sz:=CompSize+16-(CompSize mod 16); Move(buf[8], dec[0], sz); DecryptFileChunk(@dec[0], sz, Key); uncompress(@buf[0], CheckFile, @dec[0], sz); end; StreamP.Seek(-CheckSize, spCurrent); StreamP.Write(buf[0], CheckSize); CheckFile:=Checksum(@buf[0], CheckSize); CheckFS:=lpChecksumEntries[CheckIdx]; if (CheckFile<>CheckFS) and (not IgnoreCheckError) then begin if Assigned(OnError) then OnError(GetItemPath(Item), ERROR_CHECKSUM, Data); if Assigned(OnErrorObj) then OnErrorObj(GetItemPath(Item), ERROR_CHECKSUM, Data); break; end; inc(result, CheckSize); //StreamP.Position:=StreamP.Position+CheckSize; if Assigned(OnProgress) then OnProgress('', result, Size, Data); if Assigned(OnProgressObj) then OnProgressObj('', result, Size, Data); if Stop then break; end; lpManifestNodes[Item].Attributes:=lpManifestNodes[Item].Attributes and (not HL_GCF_FLAG_ENCRYPTED); fIsChangeHeader[HEADER_MANIFEST_NODES]:=true; SaveChanges(); SetLength(buf, 0); end;

मैनिफेस्टीडर के लिए चेकसम गणना

इस मान की गणना करने के लिए निम्न शीर्ष लेख संरचनाओं का उपयोग किया जाता है:

ManifestHeader
प्रकट []
फ़ाइल नाम
HashTableKeys []
HashTableIndices []
न्यूनतम फ़ुटप्रिंट्स []
UserConfig []

CS की गणना करने से पहले, निम्नलिखित फ़ील्ड रीसेट कर दिए जाते हैं:

ManifestHeader.Fingerprint
ManifestHeader.Checksum

गणना स्वयं सभी निर्दिष्ट संरचनाओं के लिए एडलर 32 फ़ंक्शन द्वारा हैश की अनुक्रमिक गणना के लिए उबालती है :

डेल्फी

 function ManifestChecksum(Header: pCache_ManifestHeader; entries, names, hashs, table, MFP, UCF: pByte): uint32_t; var tmp1, tmp2: uint32; begin tmp1:=Header.Fingerprint; tmp2:=Header.Checksum; Header.Fingerprint:=0; Header.Checksum:=0; result:=adler32(0, pAnsiChar(Header), sizeof(TCache_ManifestHeader)); result:=adler32(result, pAnsiChar(entries), sizeof(TCache_ManifestNode)*Header^.NodeCount); result:=adler32(result, pAnsiChar(names), Header^.NameSize); result:=adler32(result, pAnsiChar(hashs), sizeof(uint32)*Header^.HashTableKeyCount); result:=adler32(result, pAnsiChar(table), sizeof(uint32)*Header^.NodeCount); if Header^.NumOfMinimumFootprintFiles>0 then result:=adler32(result, pAnsiChar(MFP), sizeof(uint32)*Header^.NumOfMinimumFootprintFiles); if Header^.NumOfUserConfigFiles>0 then result:=adler32(result, pAnsiChar(UCF), sizeof(uint32)*Header^.NumOfUserConfigFiles); Header.Fingerprint:=tmp1; Header.Checksum:=tmp2; end;

निष्कर्ष

उनके विवरण की बोझिलता के कारण इस लेख में अन्य कार्यों पर विचार नहीं किया गया (सेक्टर मैप बदलते समय व्यस्त क्षेत्रों के बिटमैप्स का उपयोग करना, इस नक्शे का पुनर्निर्माण करना, और बहुत कुछ, बहुत) को रिपॉजिटरी में देखा जा सकता है (बाकी कार्यक्रमों की चर्चा जो निम्नलिखित में चर्चा की जाएगी लेख)। ये स्रोत कोड आपकी परियोजनाओं में उपयोग किए जा सकते हैं (यदि किसी को ऐसी दुर्लभताओं की आवश्यकता है ...)।

सभी स्रोत कोड के अंतिम अद्यतन की अनुमानित तिथि 2011 की दूसरी छमाही है।

पुनश्च: इस लाइब्रेरी को लिखने से मुझे बहुत मदद मिली जब विषय ऑपरेटिंग सिस्टम पर एक लैब लिख रहा थाविश्वविद्यालय में - फाइल सिस्टम (फाइल बनाना, लिखना, पढ़ना और हटाना) के काम का अनुकरण करना आवश्यक था। मेरा काम पहले और शायद, सभी समय के लिए एकमात्र था, जिसमें ब्लॉक और सेक्टरों में विभाजन के साथ फाइल सिस्टम की छवि का उपयोग किया गया था - और यह बस इस लाइब्रेरी का एक छोटा संस्करण था (बिना चेकसम के)। मैंने इस कार्य के भाग के रूप में कैश के लिए एक डीफ़्रेग्मेंटर भी जोड़ा ...

स्टीम फाइलें भाग 1 - जीसीएफ / एनसीएफ

सामान्य फ़ाइल संरचना

FileHeader

BlockAllocationTableHeader

BlockAllocationTable

FileAllocationTableHeader

FileAllocationTable

ManifestHeader

प्रकट

फ़ाइल नाम

HashTableKeys

HashTableIndices

MinimumFootprints

UserConfigs

ManifestMapHeader

ManifestMap

ChecksumDataContainer

FileIdChecksumTableHeader

FileIdChecksums

चेकसम

चेकसम हस्ताक्षर

LatestApplicationVersion

DataHeader

एल्गोरिदम

फ़ाइल का आकार गणना

नाम से एक आइटम के लिए खोजें

किसी तत्व को पूर्ण पथ मिलना

धाराओं

चेकसम फ़ाइल निष्कर्षण

फ़ाइल सामग्री को डिक्रिप्ट करें

मैनिफेस्टीडर के लिए चेकसम गणना

निष्कर्ष

More articles: