Chameleon

Chameleon Svn Source Tree

Root/branches/azimutz/Chazi/i386/libsaio/aml_generator.c

1/*␊
2 * aml_generator.c␊
3 * Chameleon␊
4 *␊
5 * Created by Mozodojo on 20/07/10.␊
6 * Copyright 2010 mozo. All rights reserved.␊
7 *␊
8 */␊
9␊
10#include "aml_generator.h"␊
11␊
12bool aml_add_to_parent(struct aml_chunk* parent, struct aml_chunk* node)␊
13{␊
14␉if (parent && node)␊
15␉{␊
16␉␉switch (parent->Type) ␊
17␉␉{␊
18␉␉␉case AML_CHUNK_NONE:␊
19␉␉␉case AML_CHUNK_BYTE:␊
20␉␉␉case AML_CHUNK_WORD:␊
21␉␉␉case AML_CHUNK_DWORD:␊
22␉␉␉case AML_CHUNK_QWORD:␊
23␉␉␉case AML_CHUNK_ALIAS:␊
24␉␉␉␉//Azi: add line breaks to these msgs (Valv)␊
25␉␉␉␉verbose("aml_add_to_parent: node doesn't support child nodes!");␊
26␉␉␉␉return false;␊
27␉␉␉case AML_CHUNK_NAME:␊
28␉␉␉␉if (parent->First) ␊
29␉␉␉␉{␊
30␉␉␉␉␉verbose("aml_add_to_parent: name node supports only one child node!");␊
31␉␉␉␉␉return false;␊
32␉␉␉␉}␊
33␉␉␉␉break;␊
34␊
35␉␉␉default:␊
36␉␉␉␉break;␊
37␉␉}␊
38␉␉␊
39␉␉if (!parent->First)␊
40␉␉␉parent->First = node;␊
41␉␉␊
42␉␉if (parent->Last)␊
43␉␉␉parent->Last->Next = node;␊
44␉␉␊
45␉␉parent->Last = node;␊
46␉␉␊
47␉␉return true;␊
48␉}␊
49␉␊
50␉return false;␊
51}␊
52␊
53struct aml_chunk* aml_create_node(struct aml_chunk* parent)␊
54{␊
55␉struct aml_chunk* node = (struct aml_chunk*)malloc(sizeof(struct aml_chunk));␊
56␉␊
57␉aml_add_to_parent(parent, node);␊
58␉␊
59␉return node;␊
60}␊
61␊
62void aml_destroy_node(struct aml_chunk* node)␊
63{␊
64␉// Delete child nodes␊
65␉struct aml_chunk* child = node->First;␊
66␉␊
67␉while (child) ␊
68␉{␊
69␉␉struct aml_chunk* next = child->Next;␊
70␉␉␊
71␉␉if (child->Buffer)␊
72␉␉␉free(child->Buffer);␊
73␉␉␊
74␉␉free(child);␊
75␉␉␊
76␉␉child = next;␊
77␉}␊
78␉␊
79␉// Free node␊
80␉if (node->Buffer)␊
81␉␉free(node->Buffer);␊
82␉␊
83␉free(node);␊
84}␊
85␊
86struct aml_chunk* aml_add_buffer(struct aml_chunk* parent, const char* buffer, unsigned int size)␊
87{␊
88␉struct aml_chunk* node = aml_create_node(parent);␊
89␉␊
90␉if (node) ␊
91␉{␊
92␉␉node->Type = AML_CHUNK_NONE;␊
93␉␉node->Length = size;␊
94␉␉node->Buffer = malloc(node->Length);␊
95␉␉memcpy(node->Buffer, buffer, node->Length);␊
96␉}␊
97␉␊
98␉return node;␊
99}␊
100␊
101struct aml_chunk* aml_add_byte(struct aml_chunk* parent, unsigned char value)␊
102{␊
103␉struct aml_chunk* node = aml_create_node(parent);␊
104␉␊
105␉if (node) ␊
106␉{␊
107␉␉node->Type = AML_CHUNK_BYTE;␊
108␉␉␊
109␉␉node->Length = 1;␊
110␉␉node->Buffer = malloc(node->Length);␊
111␉␉node->Buffer[0] = value;␊
112␉}␊
113␉␊
114␉return node;␊
115}␊
116␊
117struct aml_chunk* aml_add_word(struct aml_chunk* parent, unsigned int value)␊
118{␊
119␉struct aml_chunk* node = aml_create_node(parent);␊
120␉␊
121␉if (node) ␊
122␉{␊
123␉␉node->Type = AML_CHUNK_WORD;␊
124␉␉node->Length = 2;␊
125␉␉node->Buffer = malloc(node->Length);␊
126␉␉node->Buffer[0] = value & 0xff;␊
127␉␉node->Buffer[1] = value >> 8;␊
128␉}␊
129␉␊
130␉return node;␊
131}␊
132␊
133struct aml_chunk* aml_add_dword(struct aml_chunk* parent, unsigned long value)␊
134{␊
135␉struct aml_chunk* node = aml_create_node(parent);␊
136␉␊
137␉if (node) ␊
138␉{␊
139␉␉node->Type = AML_CHUNK_DWORD;␊
140␉␉node->Length = 4;␊
141␉␉node->Buffer = malloc(node->Length);␊
142␉␉node->Buffer[0] = value & 0xff;␊
143␉␉node->Buffer[1] = (value >> 8) & 0xff;␊
144␉␉node->Buffer[2] = (value >> 16) & 0xff;␊
145␉␉node->Buffer[3] = (value >> 24) & 0xff;␊
146␉}␊
147␉␊
148␉return node;␊
149}␊
150␊
151struct aml_chunk* aml_add_qword(struct aml_chunk* parent, unsigned long long value)␊
152{␊
153␉struct aml_chunk* node = aml_create_node(parent);␊
154␉␊
155␉if (node) ␊
156␉{␊
157␉␉node->Type = AML_CHUNK_QWORD;␊
158␉␉node->Length = 8;␊
159␉␉node->Buffer = malloc(node->Length);␊
160␉␉node->Buffer[0] = value & 0xff;␊
161␉␉node->Buffer[1] = (value >> 8) & 0xff;␊
162␉␉node->Buffer[2] = (value >> 16) & 0xff;␊
163␉␉node->Buffer[3] = (value >> 24) & 0xff;␊
164␉␉node->Buffer[4] = (value >> 32) & 0xff;␊
165␉␉node->Buffer[5] = (value >> 40) & 0xff;␊
166␉␉node->Buffer[6] = (value >> 48) & 0xff;␊
167␉␉node->Buffer[7] = (value >> 56) & 0xff;␊
168␉}␊
169␉␊
170␉return node;␊
171}␊
172␊
173unsigned int aml_fill_simple_name(char* buffer, const char* name)␊
174{␊
175␉if (strlen(name) < 4) ␊
176␉{␊
177␉␉verbose("aml_fill_simple_name: simple name %s has incorrect lengh! Must be 4.", name);␊
178␉␉return 0;␊
179␉}␊
180␉␊
181␉memcpy(buffer, name, 4);␊
182␉return 4;␊
183}␊
184␊
185unsigned int aml_fill_name(struct aml_chunk* node, const char* name)␊
186{␊
187␉if (!node) ␊
188␉␉return 0;␊
189␉␊
190␉int len = strlen(name), offset = 0, count = len / 4;␊
191␉␊
192␉if ((len % 4) > 1 || count == 0) ␊
193␉{␊
194␉␉verbose("aml_fill_name: pathname %s has incorrect length! Must be 4, 8, 12, 16, etc...", name);␊
195␉␉return 0;␊
196␉}␊
197␉␊
198␉unsigned int root = 0;␊
199␉␊
200␉if ((len % 4) == 1 && name[0] == '\\')␊
201␉␉root++;␊
202␉␉␉␊
203␉if (count == 1) ␊
204␉{␊
205␉␉node->Length = 4 + root;␊
206␉␉node->Buffer = malloc(node->Length);␊
207␉␉memcpy(node->Buffer, name, 4 + root);␊
208␉␉return node->Length;␊
209␉}␊
210␉␊
211␉if (count == 2) ␊
212␉{␊
213␉␉node->Length = 2 + 8;␊
214␉␉node->Buffer = malloc(node->Length);␊
215␉␉node->Buffer[offset++] = 0x5c; // Root Char␊
216␉␉node->Buffer[offset++] = 0x2e; // Double name␊
217␉␉memcpy(node->Buffer+offset, name + root, 8);␊
218␉␉return node->Length;␊
219␉}␊
220␉␊
221␉node->Length = 3 + count*4;␊
222␉node->Buffer = malloc(node->Length);␊
223␉node->Buffer[offset++] = 0x5c; // Root Char␊
224␉node->Buffer[offset++] = 0x2f; // Multi name␊
225␉node->Buffer[offset++] = count; // Names count␊
226␉memcpy(node->Buffer+offset, name + root, count*4);␊
227␉␊
228␉return node->Length;␊
229}␊
230␊
231struct aml_chunk* aml_add_scope(struct aml_chunk* parent, const char* name)␊
232{␊
233␉struct aml_chunk* node = aml_create_node(parent);␊
234␉␊
235␉if (node)␊
236␉{␊
237␉␉node->Type = AML_CHUNK_SCOPE;␊
238␉␉␊
239␉␉aml_fill_name(node, name);␊
240␉}␊
241␉␊
242␉return node;␊
243}␊
244␊
245struct aml_chunk* aml_add_name(struct aml_chunk* parent, const char* name)␊
246{␊
247␉struct aml_chunk* node = aml_create_node(parent);␊
248␉␊
249␉if (node)␊
250␉{␊
251␉␉node->Type = AML_CHUNK_NAME;␊
252␉␉␊
253␉␉aml_fill_name(node, name);␊
254␉}␊
255␉␊
256␉return node;␊
257}␊
258␊
259struct aml_chunk* aml_add_package(struct aml_chunk* parent)␊
260{␊
261␉struct aml_chunk* node = aml_create_node(parent);␊
262␉␊
263␉if (node)␊
264␉{␊
265␉␉node->Type = AML_CHUNK_PACKAGE;␊
266␉␉␊
267␉␉node->Length = 1;␊
268␉␉node->Buffer = malloc(node->Length);␊
269␉}␊
270␉␊
271␉return node;␊
272}␊
273␊
274struct aml_chunk* aml_add_alias(struct aml_chunk* parent, const char* name1, const char* name2)␊
275{␊
276␉struct aml_chunk* node = aml_create_node(parent);␊
277␉␊
278␉if (node)␊
279␉{␊
280␉␉node->Type = AML_CHUNK_ALIAS;␊
281␉␉␊
282␉␉node->Length = 8;␊
283␉␉node->Buffer = malloc(node->Length);␊
284␉␉aml_fill_simple_name(node->Buffer, name1);␊
285␉␉aml_fill_simple_name(node->Buffer+4, name2);␊
286␉}␊
287␉␊
288␉return node;␊
289}␊
290␊
291unsigned char aml_get_size_length(unsigned int size)␊
292{␊
293␉if (size + 1 <= 0x3f)␊
294␉␉return 1;␊
295␉else if (size + 2 <= 0x3fff)␊
296␉␉return 2;␊
297␉else if (size + 3 <= 0x3fffff)␊
298␉␉return 3;␊
299␉␊
300␉return 4;␊
301}␊
302␊
303unsigned int aml_calculate_size(struct aml_chunk* node)␊
304{␊
305␉if (node)␊
306␉{␊
307␉␉node->Size = 0;␊
308␉␉␊
309␉␉// Calculate child nodes size␊
310␉␉struct aml_chunk* child = node->First;␊
311␉␉unsigned char child_count = 0;␊
312␉␉␊
313␉␉while (child) ␊
314␉␉{␊
315␉␉␉child_count++;␊
316␉␉␉␊
317␉␉␉node->Size += aml_calculate_size(child);␊
318␉␉␉␊
319␉␉␉child = child->Next;␊
320␉␉}␊
321␉␉␊
322␉␉switch (node->Type) ␊
323␉␉{␊
324␉␉␉case AML_CHUNK_NONE:␊
325␉␉␉␉node->Size += node->Length;␊
326␉␉␉␉break;␊
327␉␉␉case AML_CHUNK_SCOPE:␊
328␉␉␉␉node->Size += 1 + node->Length;␊
329␉␉␉␉node->Size += aml_get_size_length(node->Size);␊
330␉␉␉␉break;␊
331␉␉␉case AML_CHUNK_PACKAGE:␊
332␉␉␉␉node->Buffer[0] = child_count;␊
333␉␉␉␉node->Size += 1 + node->Length;␊
334␉␉␉␉node->Size += aml_get_size_length(node->Size);␊
335␉␉␉␉break;␊
336␉␉␉␉␊
337␉␉␉case AML_CHUNK_BYTE:␊
338␉␉␉␉if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) ␊
339␉␉␉␉{␊
340␉␉␉␉␉node->Size += node->Length;␊
341␉␉␉␉}␊
342␉␉␉␉else ␊
343␉␉␉␉{␊
344␉␉␉␉␉node->Size += 1 + node->Length;␊
345␉␉␉␉}␊
346␉␉␉␉␊
347␉␉␉␉break;␊
348␉␉␉␉␊
349␉␉␉case AML_CHUNK_WORD:␊
350␉␉␉case AML_CHUNK_DWORD:␊
351␉␉␉case AML_CHUNK_QWORD:␊
352␉␉␉case AML_CHUNK_ALIAS:␊
353␉␉␉case AML_CHUNK_NAME:␊
354␉␉␉␉node->Size += 1 + node->Length;␊
355␉␉␉␉break;␊
356␉␉}␊
357␉␉␊
358␉␉return node->Size;␊
359␉}␊
360␉␊
361␉return 0;␊
362}␊
363␊
364unsigned int aml_write_byte(unsigned char value, char* buffer, unsigned int offset)␊
365{␊
366␉buffer[offset++] = value;␊
367␉␊
368␉return offset;␊
369}␊
370␊
371unsigned int aml_write_word(unsigned int value, char* buffer, unsigned int offset)␊
372{␊
373␉buffer[offset++] = value & 0xff;␊
374␉buffer[offset++] = value >> 8;␊
375␉␊
376␉return offset;␊
377}␊
378␊
379unsigned int aml_write_dword(unsigned long value, char* buffer, unsigned int offset)␊
380{␊
381␉buffer[offset++] = value & 0xff;␊
382␉buffer[offset++] = (value >> 8) & 0xff;␊
383␉buffer[offset++] = (value >> 16) & 0xff;␊
384␉buffer[offset++] = (value >> 24) & 0xff;␊
385␉␊
386␉return offset;␊
387}␊
388␊
389unsigned int aml_write_qword(unsigned long long value, char* buffer, unsigned int offset)␊
390{␊
391␉buffer[offset++] = value & 0xff;␊
392␉buffer[offset++] = (value >> 8) & 0xff;␊
393␉buffer[offset++] = (value >> 16) & 0xff;␊
394␉buffer[offset++] = (value >> 24) & 0xff;␊
395␉buffer[offset++] = (value >> 32) & 0xff;␊
396␉buffer[offset++] = (value >> 40) & 0xff;␊
397␉buffer[offset++] = (value >> 48) & 0xff;␊
398␉buffer[offset++] = (value >> 56) & 0xff;␊
399␉␊
400␉return offset;␊
401}␊
402␊
403unsigned int aml_write_buffer(const char* value, unsigned int size, char* buffer, unsigned int offset)␊
404{␊
405␉if (size > 0)␊
406␉{␊
407␉␉memcpy(buffer + offset, value, size);␊
408␉}␊
409␉␊
410␉return offset + size;␊
411}␊
412␊
413unsigned int aml_write_size(unsigned int size, char* buffer, unsigned int offset)␊
414{␊
415␉if (size <= 0x3f)␊
416␉{␊
417␉␉buffer[offset++] = size;␊
418␉}␊
419␉else if (size <= 0x3fff) ␊
420␉{␊
421␉␉buffer[offset++] = 0x40 | (size & 0xf);␊
422␉␉buffer[offset++] = (size >> 4) & 0xff;␊
423␉}␊
424␉else if (size <= 0x3fffff) ␊
425␉{␊
426␉␉buffer[offset++] = 0x80 | (size & 0xf);␊
427␉␉buffer[offset++] = (size >> 4) & 0xff;␊
428␉␉buffer[offset++] = (size >> 12) & 0xff;␊
429␉}␊
430 else ␊
431␉{␊
432␉␉buffer[offset++] = 0xc0 | (size & 0xf);␊
433␉␉buffer[offset++] = (size >> 4) & 0xff;␊
434␉␉buffer[offset++] = (size >> 12) & 0xff;␊
435␉␉buffer[offset++] = (size >> 20) & 0xff;␊
436␉}␊
437␉␊
438␉return offset;␊
439}␊
440␊
441unsigned int aml_write_node(struct aml_chunk* node, char* buffer, unsigned int offset)␊
442{␊
443␉if (node && buffer) ␊
444␉{␊
445␉␉unsigned int old = offset;␊
446␉␉␊
447␉␉switch (node->Type) ␊
448␉␉{␊
449␉␉␉case AML_CHUNK_NONE:␊
450␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
451␉␉␉␉break;␊
452␊
453␉␉␉case AML_CHUNK_SCOPE:␊
454␉␉␉case AML_CHUNK_PACKAGE:␊
455␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
456␉␉␉␉offset = aml_write_size(node->Size-1, buffer, offset);␊
457␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
458␉␉␉␉break;␊
459␉␉␉␉␊
460␉␉␉case AML_CHUNK_BYTE:␊
461␉␉␉␉if (node->Buffer[0] == 0x0 || node->Buffer[0] == 0x1) ␊
462␉␉␉␉{␊
463␉␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
464␉␉␉␉}␊
465␉␉␉␉else ␊
466␉␉␉␉{␊
467␉␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
468␉␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
469␉␉␉␉}␊
470␉␉␉␉break;␊
471␉␉␉␉␊
472␉␉␉case AML_CHUNK_WORD:␊
473␉␉␉case AML_CHUNK_DWORD:␊
474␉␉␉case AML_CHUNK_QWORD:␊
475␉␉␉case AML_CHUNK_ALIAS:␊
476␉␉␉case AML_CHUNK_NAME:␊
477␉␉␉␉offset = aml_write_byte(node->Type, buffer, offset);␊
478␉␉␉␉offset = aml_write_buffer(node->Buffer, node->Length, buffer, offset);␊
479␉␉␉␉break;␊
480␉␉␉␉␊
481␉␉␉default:␊
482␉␉␉␉break;␊
483␉␉}␊
484␊
485␉␉struct aml_chunk* child = node->First;␊
486␉␉␊
487␉␉while (child) ␊
488␉␉{␊
489␉␉␉offset = aml_write_node(child, buffer, offset);␊
490␉␉␉␊
491␉␉␉child = child->Next;␊
492␉␉}␊
493␉␉␊
494␉␉if (offset - old != node->Size) ␊
495␉␉␉verbose("Node size incorrect: 0x%x\n", node->Type);␊
496␉}␊
497␉␊
498␉return offset;␊
499}

Archive Download this file

Revision: 847