1 /*
2 * File entry extension functions
3 *
4 * Copyright (C) 2010-2020, Joachim Metz <joachim.metz@gmail.com>
5 *
6 * Refer to AUTHORS for acknowledgements.
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <common.h>
23 #include <memory.h>
24 #include <types.h>
25
26 #include "libfwsi_extension_block.h"
27 #include "libfwsi_file_entry_extension.h"
28 #include "libfwsi_file_entry_extension_values.h"
29 #include "libfwsi_libcerror.h"
30 #include "libfwsi_libuna.h"
31
32 /* Retrieves the creation time
33 * The returned time is a 32-bit version of a FAT date time value
34 * Returns 1 if successful or -1 on error
35 */
libfwsi_file_entry_extension_get_creation_time(libfwsi_extension_block_t * file_entry_extension,uint32_t * creation_time,libcerror_error_t ** error)36 int libfwsi_file_entry_extension_get_creation_time(
37 libfwsi_extension_block_t *file_entry_extension,
38 uint32_t *creation_time,
39 libcerror_error_t **error )
40 {
41 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
42 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
43 static char *function = "libfwsi_file_entry_get_creation_time";
44
45 if( file_entry_extension == NULL )
46 {
47 libcerror_error_set(
48 error,
49 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
50 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
51 "%s: invalid file entry extension.",
52 function );
53
54 return( -1 );
55 }
56 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
57
58 if( internal_extension_block->signature != 0xbeef0004UL )
59 {
60 libcerror_error_set(
61 error,
62 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
63 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
64 "%s: unsupported extension block signature.",
65 function );
66
67 return( -1 );
68 }
69 if( internal_extension_block->value == NULL )
70 {
71 libcerror_error_set(
72 error,
73 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
74 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
75 "%s: invalid extension block - missing value.",
76 function );
77
78 return( -1 );
79 }
80 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
81
82 if( creation_time == NULL )
83 {
84 libcerror_error_set(
85 error,
86 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
87 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
88 "%s: invalid creation time.",
89 function );
90
91 return( -1 );
92 }
93 *creation_time = file_entry_extension_values->creation_time;
94
95 return( 1 );
96 }
97
98 /* Retrieves the access time
99 * The returned time is a 32-bit version of a FAT date time value
100 * Returns 1 if successful or -1 on error
101 */
libfwsi_file_entry_extension_get_access_time(libfwsi_extension_block_t * file_entry_extension,uint32_t * access_time,libcerror_error_t ** error)102 int libfwsi_file_entry_extension_get_access_time(
103 libfwsi_extension_block_t *file_entry_extension,
104 uint32_t *access_time,
105 libcerror_error_t **error )
106 {
107 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
108 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
109 static char *function = "libfwsi_file_entry_get_access_time";
110
111 if( file_entry_extension == NULL )
112 {
113 libcerror_error_set(
114 error,
115 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
116 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
117 "%s: invalid file entry extension.",
118 function );
119
120 return( -1 );
121 }
122 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
123
124 if( internal_extension_block->signature != 0xbeef0004UL )
125 {
126 libcerror_error_set(
127 error,
128 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
129 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
130 "%s: unsupported extension block signature.",
131 function );
132
133 return( -1 );
134 }
135 if( internal_extension_block->value == NULL )
136 {
137 libcerror_error_set(
138 error,
139 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
140 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
141 "%s: invalid extension block - missing value.",
142 function );
143
144 return( -1 );
145 }
146 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
147
148 if( access_time == NULL )
149 {
150 libcerror_error_set(
151 error,
152 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
153 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
154 "%s: invalid access time.",
155 function );
156
157 return( -1 );
158 }
159 *access_time = file_entry_extension_values->access_time;
160
161 return( 1 );
162 }
163
164 /* Retrieves the NTFS file reference
165 * Returns 1 if successful, 0 if not available or -1 on error
166 */
libfwsi_file_entry_extension_get_file_reference(libfwsi_extension_block_t * file_entry_extension,uint64_t * file_reference,libcerror_error_t ** error)167 int libfwsi_file_entry_extension_get_file_reference(
168 libfwsi_extension_block_t *file_entry_extension,
169 uint64_t *file_reference,
170 libcerror_error_t **error )
171 {
172 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
173 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
174 static char *function = "libfwsi_file_entry_get_file_reference";
175
176 if( file_entry_extension == NULL )
177 {
178 libcerror_error_set(
179 error,
180 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
181 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
182 "%s: invalid file entry extension.",
183 function );
184
185 return( -1 );
186 }
187 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
188
189 if( internal_extension_block->signature != 0xbeef0004UL )
190 {
191 libcerror_error_set(
192 error,
193 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
194 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
195 "%s: unsupported extension block signature.",
196 function );
197
198 return( -1 );
199 }
200 if( internal_extension_block->value == NULL )
201 {
202 libcerror_error_set(
203 error,
204 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
205 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
206 "%s: invalid extension block - missing value.",
207 function );
208
209 return( -1 );
210 }
211 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
212
213 if( file_reference == NULL )
214 {
215 libcerror_error_set(
216 error,
217 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
218 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
219 "%s: invalid file reference.",
220 function );
221
222 return( -1 );
223 }
224 if( ( internal_extension_block->version < 7 )
225 || ( file_entry_extension_values->file_reference == 0 ) )
226 {
227 return( 0 );
228 }
229 *file_reference = file_entry_extension_values->file_reference;
230
231 return( 1 );
232 }
233
234 /* Retrieves the size of the UTF-8 formatted long name
235 * Returns 1 if successful, 0 if not available or -1 on error
236 */
libfwsi_file_entry_extension_get_utf8_long_name_size(libfwsi_extension_block_t * file_entry_extension,size_t * utf8_string_size,libcerror_error_t ** error)237 int libfwsi_file_entry_extension_get_utf8_long_name_size(
238 libfwsi_extension_block_t *file_entry_extension,
239 size_t *utf8_string_size,
240 libcerror_error_t **error )
241 {
242 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
243 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
244 static char *function = "libfwsi_file_entry_extension_get_utf8_long_name_size";
245
246 if( file_entry_extension == NULL )
247 {
248 libcerror_error_set(
249 error,
250 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
251 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
252 "%s: invalid file entry extension.",
253 function );
254
255 return( -1 );
256 }
257 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
258
259 if( internal_extension_block->signature != 0xbeef0004UL )
260 {
261 libcerror_error_set(
262 error,
263 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
264 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
265 "%s: unsupported extension block signature.",
266 function );
267
268 return( -1 );
269 }
270 if( internal_extension_block->value == NULL )
271 {
272 libcerror_error_set(
273 error,
274 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
275 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
276 "%s: invalid extension block - missing value.",
277 function );
278
279 return( -1 );
280 }
281 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
282
283 if( ( file_entry_extension_values->long_name == NULL )
284 || ( file_entry_extension_values->long_name_size == 0 ) )
285 {
286 return( 0 );
287 }
288 if( libuna_utf8_string_size_from_utf16_stream(
289 file_entry_extension_values->long_name,
290 file_entry_extension_values->long_name_size,
291 LIBUNA_ENDIAN_LITTLE,
292 utf8_string_size,
293 error ) != 1 )
294 {
295 libcerror_error_set(
296 error,
297 LIBCERROR_ERROR_DOMAIN_RUNTIME,
298 LIBCERROR_RUNTIME_ERROR_GET_FAILED,
299 "%s: unable to determine size of UTF-8 string.",
300 function );
301
302 return( -1 );
303 }
304 return( 1 );
305 }
306
307 /* Retrieves the UTF-8 formatted long name
308 * Returns 1 if successful, 0 if not available or -1 on error
309 */
libfwsi_file_entry_extension_get_utf8_long_name(libfwsi_extension_block_t * file_entry_extension,uint8_t * utf8_string,size_t utf8_string_size,libcerror_error_t ** error)310 int libfwsi_file_entry_extension_get_utf8_long_name(
311 libfwsi_extension_block_t *file_entry_extension,
312 uint8_t *utf8_string,
313 size_t utf8_string_size,
314 libcerror_error_t **error )
315 {
316 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
317 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
318 static char *function = "libfwsi_file_entry_extension_get_utf8_long_name";
319
320 if( file_entry_extension == NULL )
321 {
322 libcerror_error_set(
323 error,
324 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
325 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
326 "%s: invalid file entry extension.",
327 function );
328
329 return( -1 );
330 }
331 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
332
333 if( internal_extension_block->signature != 0xbeef0004UL )
334 {
335 libcerror_error_set(
336 error,
337 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
338 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
339 "%s: unsupported extension block signature.",
340 function );
341
342 return( -1 );
343 }
344 if( internal_extension_block->value == NULL )
345 {
346 libcerror_error_set(
347 error,
348 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
349 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
350 "%s: invalid extension block - missing value.",
351 function );
352
353 return( -1 );
354 }
355 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
356
357 if( ( file_entry_extension_values->long_name == NULL )
358 || ( file_entry_extension_values->long_name_size == 0 ) )
359 {
360 return( 0 );
361 }
362 if( libuna_utf8_string_copy_from_utf16_stream(
363 utf8_string,
364 utf8_string_size,
365 file_entry_extension_values->long_name,
366 file_entry_extension_values->long_name_size,
367 LIBUNA_ENDIAN_LITTLE,
368 error ) != 1 )
369 {
370 libcerror_error_set(
371 error,
372 LIBCERROR_ERROR_DOMAIN_RUNTIME,
373 LIBCERROR_RUNTIME_ERROR_SET_FAILED,
374 "%s: unable to set UTF-8 string.",
375 function );
376
377 return( -1 );
378 }
379 return( 1 );
380 }
381
382 /* Retrieves the size of the UTF-16 formatted long name
383 * Returns 1 if successful, 0 if not available or -1 on error
384 */
libfwsi_file_entry_extension_get_utf16_long_name_size(libfwsi_extension_block_t * file_entry_extension,size_t * utf16_string_size,libcerror_error_t ** error)385 int libfwsi_file_entry_extension_get_utf16_long_name_size(
386 libfwsi_extension_block_t *file_entry_extension,
387 size_t *utf16_string_size,
388 libcerror_error_t **error )
389 {
390 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
391 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
392 static char *function = "libfwsi_file_entry_extension_get_utf16_long_name_size";
393
394 if( file_entry_extension == NULL )
395 {
396 libcerror_error_set(
397 error,
398 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
399 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
400 "%s: invalid file entry extension.",
401 function );
402
403 return( -1 );
404 }
405 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
406
407 if( internal_extension_block->signature != 0xbeef0004UL )
408 {
409 libcerror_error_set(
410 error,
411 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
412 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
413 "%s: unsupported extension block signature.",
414 function );
415
416 return( -1 );
417 }
418 if( internal_extension_block->value == NULL )
419 {
420 libcerror_error_set(
421 error,
422 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
423 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
424 "%s: invalid extension block - missing value.",
425 function );
426
427 return( -1 );
428 }
429 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
430
431 if( ( file_entry_extension_values->long_name == NULL )
432 || ( file_entry_extension_values->long_name_size == 0 ) )
433 {
434 return( 0 );
435 }
436 if( libuna_utf16_string_size_from_utf16_stream(
437 file_entry_extension_values->long_name,
438 file_entry_extension_values->long_name_size,
439 LIBUNA_ENDIAN_LITTLE,
440 utf16_string_size,
441 error ) != 1 )
442 {
443 libcerror_error_set(
444 error,
445 LIBCERROR_ERROR_DOMAIN_RUNTIME,
446 LIBCERROR_RUNTIME_ERROR_GET_FAILED,
447 "%s: unable to determine size of UTF-16 string.",
448 function );
449
450 return( -1 );
451 }
452 return( 1 );
453 }
454
455 /* Retrieves the UTF-16 formatted long name
456 * Returns 1 if successful, 0 if not available or -1 on error
457 */
libfwsi_file_entry_extension_get_utf16_long_name(libfwsi_extension_block_t * file_entry_extension,uint16_t * utf16_string,size_t utf16_string_size,libcerror_error_t ** error)458 int libfwsi_file_entry_extension_get_utf16_long_name(
459 libfwsi_extension_block_t *file_entry_extension,
460 uint16_t *utf16_string,
461 size_t utf16_string_size,
462 libcerror_error_t **error )
463 {
464 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
465 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
466 static char *function = "libfwsi_file_entry_extension_get_utf16_long_name";
467
468 if( file_entry_extension == NULL )
469 {
470 libcerror_error_set(
471 error,
472 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
473 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
474 "%s: invalid file entry extension.",
475 function );
476
477 return( -1 );
478 }
479 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
480
481 if( internal_extension_block->signature != 0xbeef0004UL )
482 {
483 libcerror_error_set(
484 error,
485 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
486 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
487 "%s: unsupported extension block signature.",
488 function );
489
490 return( -1 );
491 }
492 if( internal_extension_block->value == NULL )
493 {
494 libcerror_error_set(
495 error,
496 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
497 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
498 "%s: invalid extension block - missing value.",
499 function );
500
501 return( -1 );
502 }
503 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
504
505 if( ( file_entry_extension_values->long_name == NULL )
506 || ( file_entry_extension_values->long_name_size == 0 ) )
507 {
508 return( 0 );
509 }
510 if( libuna_utf16_string_copy_from_utf16_stream(
511 utf16_string,
512 utf16_string_size,
513 file_entry_extension_values->long_name,
514 file_entry_extension_values->long_name_size,
515 LIBUNA_ENDIAN_LITTLE,
516 error ) != 1 )
517 {
518 libcerror_error_set(
519 error,
520 LIBCERROR_ERROR_DOMAIN_RUNTIME,
521 LIBCERROR_RUNTIME_ERROR_SET_FAILED,
522 "%s: unable to set UTF-16 string.",
523 function );
524
525 return( -1 );
526 }
527 return( 1 );
528 }
529
530 /* Retrieves the size of the UTF-8 formatted localized name
531 * Returns 1 if successful, 0 if not available or -1 on error
532 */
libfwsi_file_entry_extension_get_utf8_localized_name_size(libfwsi_extension_block_t * file_entry_extension,size_t * utf8_string_size,libcerror_error_t ** error)533 int libfwsi_file_entry_extension_get_utf8_localized_name_size(
534 libfwsi_extension_block_t *file_entry_extension,
535 size_t *utf8_string_size,
536 libcerror_error_t **error )
537 {
538 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
539 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
540 static char *function = "libfwsi_file_entry_extension_get_utf8_localized_name_size";
541 int result = 0;
542
543 if( file_entry_extension == NULL )
544 {
545 libcerror_error_set(
546 error,
547 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
548 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
549 "%s: invalid file entry extension.",
550 function );
551
552 return( -1 );
553 }
554 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
555
556 if( internal_extension_block->signature != 0xbeef0004UL )
557 {
558 libcerror_error_set(
559 error,
560 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
561 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
562 "%s: unsupported extension block signature.",
563 function );
564
565 return( -1 );
566 }
567 if( internal_extension_block->value == NULL )
568 {
569 libcerror_error_set(
570 error,
571 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
572 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
573 "%s: invalid extension block - missing value.",
574 function );
575
576 return( -1 );
577 }
578 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
579
580 if( ( file_entry_extension_values->localized_name == NULL )
581 || ( file_entry_extension_values->localized_name_size == 0 ) )
582 {
583 return( 0 );
584 }
585 if( internal_extension_block->version >= 7 )
586 {
587 result = libuna_utf8_string_size_from_utf16_stream(
588 file_entry_extension_values->localized_name,
589 file_entry_extension_values->localized_name_size,
590 LIBUNA_ENDIAN_LITTLE,
591 utf8_string_size,
592 error );
593 }
594 else if( internal_extension_block->version >= 3 )
595 {
596 result = libuna_utf8_string_size_from_byte_stream(
597 file_entry_extension_values->localized_name,
598 file_entry_extension_values->localized_name_size,
599 file_entry_extension_values->ascii_codepage,
600 utf8_string_size,
601 error );
602 }
603 else
604 {
605 return( 0 );
606 }
607 if( result != 1 )
608 {
609 libcerror_error_set(
610 error,
611 LIBCERROR_ERROR_DOMAIN_RUNTIME,
612 LIBCERROR_RUNTIME_ERROR_GET_FAILED,
613 "%s: unable to determine size of UTF-8 string.",
614 function );
615
616 return( -1 );
617 }
618 return( 1 );
619 }
620
621 /* Retrieves the UTF-8 formatted localized name
622 * Returns 1 if successful, 0 if not available or -1 on error
623 */
libfwsi_file_entry_extension_get_utf8_localized_name(libfwsi_extension_block_t * file_entry_extension,uint8_t * utf8_string,size_t utf8_string_size,libcerror_error_t ** error)624 int libfwsi_file_entry_extension_get_utf8_localized_name(
625 libfwsi_extension_block_t *file_entry_extension,
626 uint8_t *utf8_string,
627 size_t utf8_string_size,
628 libcerror_error_t **error )
629 {
630 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
631 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
632 static char *function = "libfwsi_file_entry_extension_get_utf8_localized_name";
633 int result = 0;
634
635 if( file_entry_extension == NULL )
636 {
637 libcerror_error_set(
638 error,
639 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
640 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
641 "%s: invalid file entry extension.",
642 function );
643
644 return( -1 );
645 }
646 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
647
648 if( internal_extension_block->signature != 0xbeef0004UL )
649 {
650 libcerror_error_set(
651 error,
652 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
653 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
654 "%s: unsupported extension block signature.",
655 function );
656
657 return( -1 );
658 }
659 if( internal_extension_block->value == NULL )
660 {
661 libcerror_error_set(
662 error,
663 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
664 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
665 "%s: invalid extension block - missing value.",
666 function );
667
668 return( -1 );
669 }
670 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
671
672 if( ( file_entry_extension_values->localized_name == NULL )
673 || ( file_entry_extension_values->localized_name_size == 0 ) )
674 {
675 return( 0 );
676 }
677 if( internal_extension_block->version >= 7 )
678 {
679 result = libuna_utf8_string_copy_from_utf16_stream(
680 utf8_string,
681 utf8_string_size,
682 file_entry_extension_values->localized_name,
683 file_entry_extension_values->localized_name_size,
684 LIBUNA_ENDIAN_LITTLE,
685 error );
686 }
687 else if( internal_extension_block->version >= 3 )
688 {
689 result = libuna_utf8_string_copy_from_byte_stream(
690 utf8_string,
691 utf8_string_size,
692 file_entry_extension_values->localized_name,
693 file_entry_extension_values->localized_name_size,
694 file_entry_extension_values->ascii_codepage,
695 error );
696 }
697 else
698 {
699 return( 0 );
700 }
701 if( result != 1 )
702 {
703 libcerror_error_set(
704 error,
705 LIBCERROR_ERROR_DOMAIN_RUNTIME,
706 LIBCERROR_RUNTIME_ERROR_SET_FAILED,
707 "%s: unable to set UTF-8 string.",
708 function );
709
710 return( -1 );
711 }
712 return( 1 );
713 }
714
715 /* Retrieves the size of the UTF-16 formatted localized name
716 * Returns 1 if successful, 0 if not available or -1 on error
717 */
libfwsi_file_entry_extension_get_utf16_localized_name_size(libfwsi_extension_block_t * file_entry_extension,size_t * utf16_string_size,libcerror_error_t ** error)718 int libfwsi_file_entry_extension_get_utf16_localized_name_size(
719 libfwsi_extension_block_t *file_entry_extension,
720 size_t *utf16_string_size,
721 libcerror_error_t **error )
722 {
723 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
724 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
725 static char *function = "libfwsi_file_entry_extension_get_utf16_localized_name_size";
726 int result = 0;
727
728 if( file_entry_extension == NULL )
729 {
730 libcerror_error_set(
731 error,
732 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
733 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
734 "%s: invalid file entry extension.",
735 function );
736
737 return( -1 );
738 }
739 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
740
741 if( internal_extension_block->signature != 0xbeef0004UL )
742 {
743 libcerror_error_set(
744 error,
745 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
746 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
747 "%s: unsupported extension block signature.",
748 function );
749
750 return( -1 );
751 }
752 if( internal_extension_block->value == NULL )
753 {
754 libcerror_error_set(
755 error,
756 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
757 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
758 "%s: invalid extension block - missing value.",
759 function );
760
761 return( -1 );
762 }
763 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
764
765 if( ( file_entry_extension_values->localized_name == NULL )
766 || ( file_entry_extension_values->localized_name_size == 0 ) )
767 {
768 return( 0 );
769 }
770 if( internal_extension_block->version >= 7 )
771 {
772 result = libuna_utf16_string_size_from_utf16_stream(
773 file_entry_extension_values->localized_name,
774 file_entry_extension_values->localized_name_size,
775 LIBUNA_ENDIAN_LITTLE,
776 utf16_string_size,
777 error );
778 }
779 else if( internal_extension_block->version >= 3 )
780 {
781 result = libuna_utf16_string_size_from_byte_stream(
782 file_entry_extension_values->localized_name,
783 file_entry_extension_values->localized_name_size,
784 file_entry_extension_values->ascii_codepage,
785 utf16_string_size,
786 error );
787 }
788 else
789 {
790 return( 0 );
791 }
792 if( result != 1 )
793 {
794 libcerror_error_set(
795 error,
796 LIBCERROR_ERROR_DOMAIN_RUNTIME,
797 LIBCERROR_RUNTIME_ERROR_GET_FAILED,
798 "%s: unable to determine size of UTF-16 string.",
799 function );
800
801 return( -1 );
802 }
803 return( 1 );
804 }
805
806 /* Retrieves the UTF-16 formatted localized name
807 * Returns 1 if successful, 0 if not available or -1 on error
808 */
libfwsi_file_entry_extension_get_utf16_localized_name(libfwsi_extension_block_t * file_entry_extension,uint16_t * utf16_string,size_t utf16_string_size,libcerror_error_t ** error)809 int libfwsi_file_entry_extension_get_utf16_localized_name(
810 libfwsi_extension_block_t *file_entry_extension,
811 uint16_t *utf16_string,
812 size_t utf16_string_size,
813 libcerror_error_t **error )
814 {
815 libfwsi_internal_extension_block_t *internal_extension_block = NULL;
816 libfwsi_file_entry_extension_values_t *file_entry_extension_values = NULL;
817 static char *function = "libfwsi_file_entry_extension_get_utf16_localized_name";
818 int result = 0;
819
820 if( file_entry_extension == NULL )
821 {
822 libcerror_error_set(
823 error,
824 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
825 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
826 "%s: invalid file entry extension.",
827 function );
828
829 return( -1 );
830 }
831 internal_extension_block = (libfwsi_internal_extension_block_t *) file_entry_extension;
832
833 if( internal_extension_block->signature != 0xbeef0004UL )
834 {
835 libcerror_error_set(
836 error,
837 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
838 LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
839 "%s: unsupported extension block signature.",
840 function );
841
842 return( -1 );
843 }
844 if( internal_extension_block->value == NULL )
845 {
846 libcerror_error_set(
847 error,
848 LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
849 LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
850 "%s: invalid extension block - missing value.",
851 function );
852
853 return( -1 );
854 }
855 file_entry_extension_values = (libfwsi_file_entry_extension_values_t *) internal_extension_block->value;
856
857 if( ( file_entry_extension_values->localized_name == NULL )
858 || ( file_entry_extension_values->localized_name_size == 0 ) )
859 {
860 return( 0 );
861 }
862 if( internal_extension_block->version >= 7 )
863 {
864 result = libuna_utf16_string_copy_from_utf16_stream(
865 utf16_string,
866 utf16_string_size,
867 file_entry_extension_values->localized_name,
868 file_entry_extension_values->localized_name_size,
869 LIBUNA_ENDIAN_LITTLE,
870 error );
871 }
872 else if( internal_extension_block->version >= 3 )
873 {
874 result = libuna_utf16_string_copy_from_byte_stream(
875 utf16_string,
876 utf16_string_size,
877 file_entry_extension_values->localized_name,
878 file_entry_extension_values->localized_name_size,
879 file_entry_extension_values->ascii_codepage,
880 error );
881 }
882 else
883 {
884 return( 0 );
885 }
886 if( result != 1 )
887 {
888 libcerror_error_set(
889 error,
890 LIBCERROR_ERROR_DOMAIN_RUNTIME,
891 LIBCERROR_RUNTIME_ERROR_SET_FAILED,
892 "%s: unable to set UTF-16 string.",
893 function );
894
895 return( -1 );
896 }
897 return( 1 );
898 }
899
900