1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This is the transformation and adjustment for Windows X86 executables.
#ifndef COURGETTE_WIN32_X86_GENERATOR_H_
#define COURGETTE_WIN32_X86_GENERATOR_H_
#include "base/scoped_ptr.h"
#include "courgette/ensemble.h"
namespace courgette {
class CourgetteWin32X86PatchGenerator : public TransformationPatchGenerator {
public:
CourgetteWin32X86PatchGenerator(Element* old_element,
Element* new_element,
CourgetteWin32X86Patcher* patcher)
: TransformationPatchGenerator(old_element, new_element, patcher) {
}
CourgettePatchFile::TransformationMethodId Kind() {
return CourgettePatchFile::T_COURGETTE_WIN32_X86;
}
Status WriteInitialParameters(SinkStream* parameter_stream) {
parameter_stream->WriteVarint32(old_element_->offset_in_ensemble());
parameter_stream->WriteVarint32(old_element_->region().length());
return C_OK;
// TODO(sra): Initialize |patcher_| with these parameters.
}
Status PredictTransformParameters(SinkStreamSet* prediction) {
return TransformationPatchGenerator::PredictTransformParameters(prediction);
}
Status CorrectedTransformParameters(SinkStreamSet* parameters) {
// No code needed to write an 'empty' parameter set.
return C_OK;
}
// The format of a transformed_element is a serialized EncodedProgram. We
// first disassemble the original old and new Elements into AssemblyPrograms.
// Then we adjust the new AssemblyProgram to make it as much like the old one
// as possible, before converting the AssemblyPrograms to EncodedPrograms and
// serializing them.
Status Transform(SourceStreamSet* corrected_parameters,
SinkStreamSet* old_transformed_element,
SinkStreamSet* new_transformed_element) {
// Don't expect any corrected parameters.
if (!corrected_parameters->Empty())
return C_GENERAL_ERROR;
// Generate old version of program using |corrected_parameters|.
// TODO(sra): refactor to use same code from patcher_.
AssemblyProgram* old_program = NULL;
Status old_parse_status =
ParseWin32X86PE(old_element_->region().start(),
old_element_->region().length(),
&old_program);
if (old_parse_status != C_OK)
return old_parse_status;
AssemblyProgram* new_program = NULL;
Status new_parse_status =
ParseWin32X86PE(new_element_->region().start(),
new_element_->region().length(),
&new_program);
if (new_parse_status != C_OK) {
DeleteAssemblyProgram(old_program);
return new_parse_status;
}
EncodedProgram* old_encoded = NULL;
Status old_encode_status = Encode(old_program, &old_encoded);
if (old_encode_status != C_OK) {
DeleteAssemblyProgram(old_program);
return old_encode_status;
}
Status old_write_status =
WriteEncodedProgram(old_encoded, old_transformed_element);
DeleteEncodedProgram(old_encoded);
if (old_write_status != C_OK) {
DeleteAssemblyProgram(old_program);
return old_write_status;
}
Status adjust_status = Adjust(*old_program, new_program);
DeleteAssemblyProgram(old_program);
if (adjust_status != C_OK) {
DeleteAssemblyProgram(new_program);
return adjust_status;
}
EncodedProgram* new_encoded = NULL;
Status new_encode_status = Encode(new_program, &new_encoded);
DeleteAssemblyProgram(new_program);
if (new_encode_status != C_OK)
return new_encode_status;
Status new_write_status =
WriteEncodedProgram(new_encoded, new_transformed_element);
DeleteEncodedProgram(new_encoded);
if (new_write_status != C_OK)
return new_write_status;
return C_OK;
}
Status Reform(SourceStreamSet* transformed_element,
SinkStream* reformed_element) {
return TransformationPatchGenerator::Reform(transformed_element,
reformed_element);
}
private:
~CourgetteWin32X86PatchGenerator() { }
DISALLOW_COPY_AND_ASSIGN(CourgetteWin32X86PatchGenerator);
};
} // namespace courgette
#endif // COURGETTE_WIN32_X86_GENERATOR_H_
|
