Lines Matching refs:buffer
223 static int sanity_indx_list(const char *buffer, u32 k, u32 end)
233 lth = getle16(buffer,k+8);
242 (int)getle16(buffer,k+12),(int)k);
246 memcpy(&inode, &buffer[k + 20], 8);
251 (int)getle16(buffer,k+12),(int)k);
256 (long)getle32(buffer,k + 16),
258 (int)getle16(buffer,k+12),(int)k);
263 (long)getle32(buffer,k + 20),
265 (int)getle16(buffer,k+12),(int)k);
270 (long long)getle64(buffer,k),
272 (int)getle16(buffer,k+12),(int)k);
279 done = (feedle16(buffer,k+12) & INDEX_ENTRY_END) || !lth;
304 static int sanity_mft(const char *buffer)
317 record = (const MFT_RECORD*)buffer;
321 attr = (const ATTR_RECORD*)&buffer[k];
349 && buffer[k + 88]) {
353 showname(" ",&buffer[k+90],
354 buffer[k + 88] & 255);
361 && sanity_indx_list(buffer,
367 attr = (const ATTR_RECORD*)&buffer[k];
390 static int sanity_indx(ntfs_volume *vol, const char *buffer)
397 indx = (const INDEX_BLOCK*)buffer;
400 err = sanity_indx_list(buffer, k,
418 * Allocate a buffer and read a full set of raw clusters
426 char *buffer;
437 buffer = (char*)NULL;
439 buffer = (char*)malloc(clustersz*count);
441 if (buffer) {
446 target = buffer + clustersz*i;
478 free(buffer);
479 buffer = (char*)NULL;
482 return (buffer);
489 * With option -n a copy of the buffer is kept in memory for later use.
493 char *buffer)
509 source = buffer + clustersz*i;
531 source = buffer + clustersz*i;
548 char *buffer)
564 source = buffer + clustersz*i;
578 * Allocate a buffer and read a single protected record
584 char *buffer;
590 buffer = read_raw(vol, logr);
593 * make a partial copy and free the full buffer
595 if (buffer && (size < clustersz)) {
596 full = buffer;
597 buffer = (char*)malloc(size);
598 if (buffer) {
601 memcpy(buffer, full + pos, size);
605 if (buffer && (ntfs_mst_post_read_fixup_warn(
606 (NTFS_RECORD*)buffer, size, FALSE) < 0)) {
614 free(buffer);
615 buffer = (char*)NULL;
617 return (buffer);
621 * Protect a single record, write, and deallocate the buffer
623 * With option -n a copy of the buffer is kept in protected form in
630 char *buffer, u32 size)
643 if ((size == mftrecsz) && !memcmp(buffer,"FILE",4)) {
644 record = (MFT_RECORD*)buffer;
658 err = sanity_mft(buffer);
669 if ((size == vol->indx_record_size) && !memcmp(buffer,"INDX",4)) {
670 indx = (INDEX_BLOCK*)buffer;
679 err = sanity_indx(vol, buffer);
690 if (!ntfs_mst_pre_write_fixup((NTFS_RECORD*)buffer, size)) {
700 memcpy(full + pos, buffer, size);
710 err = write_raw(vol, logr, buffer);
712 err = write_mirr(vol, logr, buffer);
863 char *buffer, const char *data, u32 target, u32 length)
880 attr = (ATTR_RECORD*)(buffer
884 dump(&buffer[target], length);
886 dump(buffer,mftrecsz);
896 && !sanity_mft(buffer)) {
897 changed = memcmp(buffer + target, data, length);
900 memcpy(buffer + target, data, length);
903 dump(buffer + target, length);
906 buffer, mftrecsz);
917 char *buffer, const char *data, const char *expected,
934 attr = (ATTR_RECORD*)(buffer
938 dump(&buffer[target], length);
945 found = !memcmp(buffer + target, expected, length);
948 memcpy(buffer + target, data, length);
951 dump(buffer + target, length);
954 buffer, mftrecsz);
970 char *buffer, const char *data, u32 target, u32 length)
988 dump(&buffer[target], length);
991 changed = memcmp(buffer + target, data, length);
994 memcpy(buffer + target, data, length);
997 dump(buffer + target, length);
1000 buffer, xsize);
1015 char *buffer, const char *data, u32 target,
1031 entry = (MFT_RECORD*)buffer;
1035 dump(buffer + target,length);
1043 found = !memcmp(buffer + target,
1051 memmove(buffer + target + resize,
1052 buffer + target,
1055 memcpy(buffer + target, data, length);
1057 memset(buffer + target, 0, length);
1062 dump(buffer + target, length);
1065 buffer, mftrecsz);
1095 char *buffer, const char *data, u32 target,
1113 entry = (MFT_RECORD*)buffer;
1114 attr = (ATTR_RECORD*)(buffer
1118 dump(buffer + target,length);
1128 found = !memcmp(buffer + target, data, length);
1132 memmove(buffer + target + resize,
1133 buffer + target,
1137 memcpy(buffer + target, data, length);
1139 memset(buffer + target, 0, length);
1144 dump(buffer + target, length);
1147 buffer, mftrecsz);
1177 char *buffer, const char *data, u32 target,
1196 entry = (MFT_RECORD*)buffer;
1197 attr = (ATTR_RECORD*)(buffer
1202 dump(buffer + target,length);
1205 dump(buffer, mftrecsz);
1215 found = !memcmp(buffer + target, data, length);
1219 memmove(buffer + target + length,
1220 buffer + target,
1222 memcpy(buffer + target, data, length);
1242 dump(buffer + target, 2*length);
1245 buffer, mftrecsz);
1260 char *buffer, const char *data, u32 target,
1278 entry = (MFT_RECORD*)buffer;
1279 attr = (ATTR_RECORD*)(buffer
1283 dump(buffer + target,length);
1290 found = !memcmp(buffer + target, data,
1293 found = !memcmp(buffer + target, data, length);
1301 (int)matchcount(buffer + target, data,
1319 memmove(buffer + target,
1320 buffer + target + length,
1328 dump(buffer + target, length);
1331 buffer, mftrecsz);
1346 char *buffer, const char *data, u32 target,
1364 entry = (MFT_RECORD*)buffer;
1367 dump(buffer + target,length);
1376 found = !memcmp(buffer + target, data, length);
1383 memmove(buffer + target,
1384 buffer + target - resize,
1390 dump(buffer + target, length);
1393 buffer, mftrecsz);
1404 char *buffer, const char *data, u32 target,
1424 entry = (MFT_RECORD*)buffer;
1425 attr = (ATTR_RECORD*)(buffer
1429 dump(buffer + target,length);
1439 found = !memcmp(buffer + target, data, length);
1446 //dump(buffer + target, oldlength);
1453 memmove(buffer + target + length,
1454 buffer + target + oldlength,
1458 memcpy(buffer + target, data, length);
1460 memset(buffer + target, 0, length);
1463 memmove(buffer + target,
1464 buffer + target - resize,
1471 dump(buffer + target, length);
1474 buffer, mftrecsz);
1485 char *buffer, const char *data, u32 target, u32 length)
1500 indx = (INDEX_BLOCK*)(buffer
1504 dump(&buffer[target], length);
1510 changed = memcmp(buffer + target, data, length);
1514 memcpy(buffer + target, data, length);
1517 dump(&buffer[target], length);
1520 buffer, xsize);
1534 static int delete_names(char *buffer)
1543 record = (MFT_RECORD*)buffer;
1548 attr = (ATTR_RECORD*)&buffer[pos];
1553 &buffer[pos+90], buffer[pos+88] & 255);
1554 memmove(buffer + pos, buffer + pos + length,
1606 static int insert_index_allocation(ntfs_volume *vol, char *buffer, u32 offs)
1625 record = (MFT_RECORD*)buffer;
1628 attr = (ATTR_RECORD*)&buffer[pos];
1632 attr = (ATTR_RECORD*)&buffer[pos];
1641 memmove(buffer + offs + addedlength, buffer + offs,
1647 attr = (ATTR_RECORD*)&buffer[offs];
1651 namelength = buffer[pos + 9] & 255;
1654 memcpy(buffer + offs + 0x40, buffer + pos + 0x18,
1673 attr = (ATTR_RECORD*)&buffer[offs + length - 8];
1677 namelength = buffer[pos + 9] & 255;
1680 memcpy(buffer + offs + length - 8 + 0x18,
1681 buffer + pos + 0x18, 2*namelength);
1692 err = sanity_mft(buffer);
1784 char *buffer)
1797 indx = (INDEX_BLOCK*)buffer;
1813 ixhead = (INDEX_ENTRY_HEADER*)(buffer + 0x28);
1816 ixentry = (INDEX_ENTRY*)(buffer + 0x40);
1826 char *buffer)
1840 dump(buffer + target,length);
1843 memset(buffer + target, 0, length);
1845 buffer, mftrecsz);
1854 dump(buffer,mftrecsz);
1861 char *buffer)
1887 indx = (INDEX_BLOCK*)(buffer
1891 dump(&buffer[target], length);
1897 found = !memcmp(buffer + target, data, length);
1901 memmove(buffer + target + length,
1902 buffer + target,
1904 memcpy(buffer + target, data, length);
1910 dump(&buffer[target], length);
1913 buffer, xsize);
1924 const struct ACTION_RECORD *action, char *buffer)
1950 entry = (MFT_RECORD*)buffer;
1951 attr = (ATTR_RECORD*)(buffer
1957 dump(buffer + target,length);
1963 found = !memcmp(buffer + target, data, length);
1967 memmove(buffer + target + length,
1968 buffer + target,
1970 memcpy(buffer + target, data, length);
1974 dump(buffer + target, length);
1977 buffer, mftrecsz);
1989 char *buffer __attribute__((unused)))
2004 const struct ACTION_RECORD *action, char *buffer)
2028 record = (MFT_RECORD*)buffer;
2031 dump(buffer,mftrecsz);
2034 changed = memcmp(buffer + target, data, length);
2037 memcpy(buffer + target, data, length);
2041 dump(buffer,mftrecsz);
2044 buffer, mftrecsz);
2057 const struct ACTION_RECORD *action, char *buffer)
2074 err = insert_resident(vol, action, buffer, data,
2080 const struct ACTION_RECORD *action, char *buffer)
2096 err = remove_resident(vol, action, buffer, data,
2102 const struct ACTION_RECORD *action, char *buffer)
2128 dump(buffer,mftrecsz);
2130 record = (MFT_RECORD*)buffer;
2133 changed = (length && memcmp(buffer + target, data, length))
2137 memcpy(buffer + target, data, length);
2141 dump(buffer,mftrecsz);
2144 buffer, mftrecsz);
2155 const struct ACTION_RECORD *action, char *buffer)
2181 indx = (INDEX_BLOCK*)(buffer
2185 dump(&buffer[target], length);
2193 || !memcmp(buffer + target, data, length);
2197 memmove(buffer + target,
2198 buffer + target + length,
2204 buffer, xsize);
2215 const struct ACTION_RECORD *action, char *buffer)
2242 entry = (MFT_RECORD*)buffer;
2243 attr = (ATTR_RECORD*)(buffer
2249 dump(buffer + target,length);
2257 || !memcmp(buffer + target, data, length);
2262 memmove(buffer + target,
2263 buffer + target + length,
2268 dump(buffer + target, length);
2271 buffer, mftrecsz);
2282 const struct ACTION_RECORD *action, char *buffer)
2313 ntfs_bit_set((u8*)buffer, firstbit + i, wanted);
2314 if (!write_raw(vol, &action->record, buffer)) {
2406 char *buffer)
2422 err = change_resident(vol, action, buffer,
2428 const struct ACTION_RECORD *action, char *buffer)
2445 err = update_index(vol, action, buffer, data, target, length);
2450 const struct ACTION_RECORD *action, char *buffer)
2465 err = change_index_value(vol, action, buffer, data, target, length);
2470 const struct ACTION_RECORD *action, char *buffer)
2502 dump(&buffer[target], length);
2504 entry = (MFT_RECORD*)buffer;
2505 attr = (ATTR_RECORD*)(buffer
2514 changed = memcmp(buffer + target, data, length);
2520 memmove(buffer + target + length,
2521 buffer + source + length,
2525 memmove(buffer + target + length,
2526 buffer + source + length,
2529 memcpy(buffer + target, data, length);
2541 dump(buffer + target, length);
2546 buffer, mftrecsz);
2558 const struct ACTION_RECORD *action, char *buffer)
2594 dump(&buffer[target], length);
2599 || memcmp(buffer + target, data, length);
2602 memcpy(buffer + target, data, length);
2605 dump(buffer + target, length);
2608 buffer, mftrecsz);
2617 err = expand_resident(vol, action, buffer, data,
2620 err = shrink_resident(vol, action, buffer, data,
2627 const struct ACTION_RECORD *action, char *buffer)
2650 err = change_resident(vol, action, buffer, data,
2653 err = change_resident_expect(vol, action, buffer, data,
2659 const struct ACTION_RECORD *action, char *buffer)
2679 target += getle16(buffer, target + 8) - length;
2680 err = change_resident_expect(vol, action, buffer, data,
2687 const struct ACTION_RECORD *action, char *buffer)
2722 dump(&buffer[target], length);
2726 changed = memcmp(buffer + target, data, length);
2728 for (i=0; (i<length) && !buffer[target+i]; i++) { }
2734 memcpy(buffer + target, data, length);
2736 memset(buffer + target, 0, length);
2739 dump(buffer + target, length);
2741 err = write_raw(vol, &action->record, buffer);
2753 const struct ACTION_RECORD *action, char *buffer)
2770 target += getle16(buffer, target + 8) - length;
2771 err = update_index(vol, action, buffer, data, target, length);
2777 const struct ACTION_RECORD *action, char *buffer)
2813 dump(&buffer[target], length);
2816 changed = memcmp(buffer + target, data, length);
2819 memcpy(buffer + target, data, length);
2822 dump(buffer + target, length);
2825 buffer, mftrecsz);
2834 err = add_resident(vol, action, buffer, data,
2837 err = delete_resident(vol, action, buffer, data,
2844 const struct ACTION_RECORD *action, char *buffer)
2870 indx = (INDEX_BLOCK*)buffer;
2876 dump(&buffer[target], length);
2882 changed = memcmp(buffer + target, data, length);
2886 memcpy(buffer + target, data, length);
2892 dump(&buffer[target], length);
2895 buffer, xsize);
2907 char *buffer __attribute__((unused)))
2933 const struct ACTION_RECORD *action, char *buffer)
2959 indx = (INDEX_BLOCK*)(buffer
2963 dump(&buffer[target], length);
2969 found = index_match_undo(buffer + target, data, length);
2973 memmove(buffer + target,
2974 buffer + target + length,
2980 buffer, xsize);
2982 sanity_indx(vol,buffer);
2984 dump(buffer,xsize);
2995 const struct ACTION_RECORD *action, char *buffer)
3021 entry = (MFT_RECORD*)buffer;
3022 attr = (ATTR_RECORD*)(buffer
3028 dump(buffer + target,length);
3034 found = index_match_undo(buffer + target, data, length);
3038 memmove(buffer + target,
3039 buffer + target + length,
3044 dump(buffer + target, length);
3047 buffer, mftrecsz);
3058 const struct ACTION_RECORD *action, char *buffer)
3074 err = remove_resident(vol, action, buffer, data,
3080 const struct ACTION_RECORD *action, char *buffer)
3096 err = insert_resident(vol, action, buffer, data,
3102 const struct ACTION_RECORD *action, char *buffer)
3129 indx = (INDEX_BLOCK*)(buffer
3133 dump(&buffer[target], length);
3138 && !sanity_indx(vol,buffer)) {
3140 found = !memcmp(buffer + target, data, length);
3144 memmove(buffer + target + length,
3145 buffer + target,
3147 memcpy(buffer + target, data, length);
3153 dump(&buffer[target], length);
3158 buffer, xsize);
3169 const struct ACTION_RECORD *action, char *buffer)
3195 entry = (MFT_RECORD*)buffer;
3196 attr = (ATTR_RECORD*)(buffer
3204 dump((char*)buffer,512);
3206 dump(buffer + target,length);
3210 dump(buffer + target,length);
3216 found = !memcmp(buffer + target, data, length);
3221 memmove(buffer + target + length,
3222 buffer + target,
3224 memcpy(buffer + target, data, length);
3228 dump(buffer + target, length);
3231 buffer, mftrecsz);
3242 const struct ACTION_RECORD *action, char *buffer)
3267 record = (MFT_RECORD*)buffer;
3270 dump(buffer,mftrecsz);
3273 changed = memcmp(buffer + target, data, length);
3276 memcpy(buffer + target, data, length);
3280 dump(buffer,mftrecsz);
3283 buffer, mftrecsz);
3294 const struct ACTION_RECORD *action, char *buffer)
3320 dump(buffer,mftrecsz);
3322 record = (MFT_RECORD*)buffer;
3324 changed = memcmp(buffer + target, data, length)
3328 memcpy(buffer + target, data, length);
3343 err = delete_names(buffer);
3347 dump(buffer,mftrecsz);
3352 buffer, mftrecsz);
3363 const struct ACTION_RECORD *action, char *buffer)
3394 ntfs_bit_set((u8*)buffer, firstbit + i, wanted);
3395 if (!write_raw(vol, &action->record, buffer)) {
3476 const struct ACTION_RECORD *action, char *buffer)
3495 entry = (MFT_RECORD*)buffer;
3497 err = change_resident(vol, action, buffer,
3502 attr = (ATTR_RECORD*)(buffer + offs);
3504 err = insert_index_allocation(vol, buffer, offs);
3506 err = change_resident(vol, action, buffer,
3509 err = change_resident(vol, action, buffer,
3516 char *buffer)
3533 err = update_index(vol, action, buffer, data, target, length);
3538 const struct ACTION_RECORD *action, char *buffer)
3562 dump(&buffer[target], length);
3565 changed = length && memcmp(buffer + target, data, length);
3568 memcpy(buffer + target, data, length);
3571 dump(buffer + target, length);
3573 err = write_protected(vol, &action->record, buffer,
3585 char *buffer)
3602 target += getle16(buffer, target + 8) - length;
3603 err = update_index(vol, action, buffer, data, target, length);
3609 char *buffer)
3642 dump(&buffer[target], length);
3644 entry = (MFT_RECORD*)buffer;
3645 attr = (ATTR_RECORD*)(buffer
3654 changed = memcmp(buffer + target, data, length);
3660 memmove(buffer + target + length,
3661 buffer + source + length,
3665 memmove(buffer + target + length,
3666 buffer + source + length,
3669 memcpy(buffer + target, data, length);
3681 dump(buffer + target, length);
3685 &action->record, buffer,
3698 const struct ACTION_RECORD *action, char *buffer)
3733 dump(&buffer[target], length);
3736 changed = memcmp(buffer + target, data, length);
3739 memcpy(buffer + target, data, length);
3742 dump(buffer + target, length);
3745 buffer, mftrecsz);
3754 err = expand_resident(vol, action, buffer, data,
3757 err = shrink_resident(vol, action, buffer, data,
3764 const struct ACTION_RECORD *action, char *buffer)
3785 err = change_resident_expect(vol, action, buffer, data, expected,
3791 const struct ACTION_RECORD *action, char *buffer)
3811 target += getle16(buffer, target + 8) - length;
3812 err = change_resident_expect(vol, action, buffer, data,
3819 const struct ACTION_RECORD *action, char *buffer)
3846 dump(&buffer[target], length);
3849 changed = memcmp(buffer + target, data, length);
3852 memcpy(buffer + target, data, length);
3855 dump(buffer + target, length);
3857 err = write_raw(vol, &action->record, buffer);
3879 const struct ACTION_RECORD *action, char *buffer)
3915 dump(&buffer[target], length);
3918 changed = memcmp(buffer + target, data, length);
3921 memcpy(buffer + target, data, length);
3924 dump(buffer + target, length);
3927 buffer, mftrecsz);
3936 err = add_resident(vol, action, buffer, data,
3939 err = delete_resident(vol, action, buffer, data,
3946 const struct ACTION_RECORD *action, char *buffer)
3982 dump(&buffer[target], length);
3985 changed = memcmp(buffer + target, data, length);
3988 memcpy(buffer + target, data, length);
3991 dump(buffer + target, length);
3994 buffer, mftrecsz);
4097 const struct ACTION_RECORD *action, char *buffer)
4109 err = redo_add_index(vol, action, buffer);
4114 err = redo_add_root_index(vol, action, buffer);
4121 err = redo_force_bits(vol, action, buffer);
4126 err = redo_compensate(vol, action, buffer);
4133 err = redo_create_attribute(vol, action, buffer);
4140 err = redo_delete_file(vol, action, buffer);
4147 err = redo_delete_attribute(vol, action, buffer);
4154 err = redo_delete_index(vol, action, buffer);
4161 err = redo_delete_root_index(vol, action, buffer);
4166 err = redo_create_file(vol, action, buffer);
4176 err = redo_force_bits(vol, action, buffer);
4183 err = redo_update_vcn(vol, action, buffer);
4188 err = redo_update_root_vcn(vol, action, buffer);
4195 err = redo_sizes(vol, action, buffer);
4202 err = redo_update_index(vol, action, buffer);
4209 err = redo_update_root_index(vol, action, buffer);
4214 err = redo_update_mapping(vol, action, buffer);
4219 err = redo_update_index_value(vol, action, buffer);
4222 err = redo_update_value(vol, action, buffer);
4234 err = redo_update_resident(vol, action, buffer);
4239 err = redo_action37(vol, action, buffer);
4244 err = redo_write_end(vol, action, buffer);
4251 err = redo_write_index(vol, action, buffer);
4279 * initialized), a zeroed buffer is allocated.
4286 char *buffer;
4307 buffer = (char*)NULL;
4388 buffer = read_protected(vol, &action->record,
4390 entry = (MFT_RECORD*)buffer;
4405 if (!buffer)
4406 buffer = (char*)calloc(1, mftrecsz);
4407 if (buffer)
4430 buffer = read_protected(vol, &action->record,
4432 indx = (INDEX_BLOCK*)buffer;
4447 if (!buffer)
4448 buffer = (char*)calloc(1, xsize);
4449 if (buffer)
4470 buffer = read_raw(vol, &action->record);
4471 if (!buffer)
4476 buffer = (char*)NULL;
4480 err = distribute_redos(vol, action, buffer);
4489 if (buffer)
4490 free(buffer);
4521 char *buffer)
4533 err = undo_add_index(vol, action, buffer);
4538 err = undo_add_root_index(vol, action, buffer);
4543 err = undo_force_bits(vol, action, buffer);
4548 err = undo_create_attribute(vol, action, buffer);
4553 err = undo_delete_file(vol, action, buffer);
4558 err = undo_delete_attribute(vol, action, buffer);
4563 err = undo_delete_index(vol, action, buffer);
4568 err = undo_delete_root_index(vol, action, buffer);
4573 err = undo_create_file(vol, action, buffer);
4583 err = undo_force_bits(vol, action, buffer);
4588 err = undo_update_vcn(vol, action, buffer);
4593 err = undo_update_root_vcn(vol, action, buffer);
4598 err = undo_sizes(vol, action, buffer);
4603 err = undo_update_index(vol, action, buffer);
4608 err = undo_update_root_index(vol, action, buffer);
4613 err = undo_update_mapping(vol, action, buffer);
4618 err = undo_update_index_value(vol, action, buffer);
4621 err = undo_update_value(vol, action, buffer);
4631 err = undo_update_resident(vol, action, buffer);
4636 err = undo_action37(vol, action, buffer);
4641 err = undo_write_end(vol, action, buffer);
4646 err = undo_write_index(vol, action, buffer);
4677 char *buffer;
4694 buffer = (char*)NULL;
4767 buffer = read_protected(vol, &action->record, mftrecsz, TRUE);
4768 entry = (MFT_RECORD*)buffer;
4807 buffer = read_protected(vol, &action->record, xsize, TRUE);
4808 indx = (INDEX_BLOCK*)buffer;
4844 buffer = (char*)calloc(1, xsize);
4845 if (buffer)
4847 action, buffer);
4859 buffer = read_raw(vol, &action->record);
4860 if (!buffer)
4867 buffer = (char*)NULL;
4871 err = distribute_undos(vol, action, buffer);
4874 if (buffer)
4875 free(buffer);