RTEMS-6
Annotated Report
libuntar
Sun Feb 28 23:26:51 2021
00105880 <Untar_FromChunk_Print>:
{
105880: 55 push %ebp
105881: 89 e5 mov %esp,%ebp
105883: 57 push %edi
105884: 56 push %esi
105885: 53 push %ebx
105886: 83 ec 2c sub $0x2c,%esp
while (todo > 0) {
105889: 8b 7d 10 mov 0x10(%ebp),%edi
{
10588c: 8b 5d 08 mov 0x8(%ebp),%ebx
context->base.printer = printer;
10588f: 8b 45 14 mov 0x14(%ebp),%eax
while (todo > 0) {
105892: 85 ff test %edi,%edi
context->base.printer = printer;
105894: 89 43 7c mov %eax,0x7c(%ebx)
while (todo > 0) {
105897: 0f 84 8e 00 00 00 je 10592b <Untar_FromChunk_Print+0xab>
done = 0;
10589d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if (strncmp(&bufr[257], "ustar", 5)) {
1058a4: 8d 83 e9 01 00 00 lea 0x1e9(%ebx),%eax
1058aa: 89 45 dc mov %eax,-0x24(%ebp)
switch (context->state) {
1058ad: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
1058b3: 83 f8 01 cmp $0x1,%eax
1058b6: 74 28 je 1058e0 <Untar_FromChunk_Print+0x60>
1058b8: 83 f8 02 cmp $0x2,%eax
1058bb: 0f 84 5f 01 00 00 je 105a20 <Untar_FromChunk_Print+0x1a0>
1058c1: 85 c0 test %eax,%eax
1058c3: 74 7b je 105940 <Untar_FromChunk_Print+0xc0> <== ALWAYS TAKEN
1058c5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
1058ca: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
1058cd: 5b pop %ebx <== NOT EXECUTED
1058ce: 5e pop %esi <== NOT EXECUTED
1058cf: 5f pop %edi <== NOT EXECUTED
1058d0: 5d pop %ebp <== NOT EXECUTED
1058d1: c3 ret <== NOT EXECUTED
1058d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1058d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
remaining = context->base.file_size - context->done_bytes;
1058e0: 8b 53 70 mov 0x70(%ebx),%edx
1058e3: 8b 83 e8 02 00 00 mov 0x2e8(%ebx),%eax
consume = MIN(remaining, todo);
1058e9: 89 d7 mov %edx,%edi
1058eb: 29 c7 sub %eax,%edi
1058ed: 3b 7d 10 cmp 0x10(%ebp),%edi
1058f0: 89 7d e4 mov %edi,-0x1c(%ebp)
1058f3: 0f 87 e7 01 00 00 ja 105ae0 <Untar_FromChunk_Print+0x260>
context->done_bytes += consume;
1058f9: 8b 7d e4 mov -0x1c(%ebp),%edi
1058fc: 01 f8 add %edi,%eax
1058fe: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx)
if (context->done_bytes == context->base.file_size) {
105904: 39 c2 cmp %eax,%edx
105906: 75 18 jne 105920 <Untar_FromChunk_Print+0xa0>
context->state = UNTAR_CHUNK_HEADER;
105908: 31 c9 xor %ecx,%ecx
context->done_bytes = 0;
10590a: 31 f6 xor %esi,%esi
context->state = UNTAR_CHUNK_HEADER;
10590c: 89 8b e4 00 00 00 mov %ecx,0xe4(%ebx)
context->done_bytes = 0;
105912: 89 b3 e8 02 00 00 mov %esi,0x2e8(%ebx)
105918: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10591f: 90 nop
done += consume;
105920: 8b 4d e4 mov -0x1c(%ebp),%ecx
105923: 01 4d e0 add %ecx,-0x20(%ebp)
while (todo > 0) {
105926: 29 4d 10 sub %ecx,0x10(%ebp)
105929: 75 82 jne 1058ad <Untar_FromChunk_Print+0x2d> <== NEVER TAKEN
}
10592b: 83 c4 2c add $0x2c,%esp
return UNTAR_SUCCESSFUL;
10592e: 31 c0 xor %eax,%eax
}
105930: 5b pop %ebx
105931: 5e pop %esi
105932: 5f pop %edi
105933: 5d pop %ebp
105934: c3 ret
105935: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10593c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
remaining = 512 - context->done_bytes;
105940: 8b 83 e8 02 00 00 mov 0x2e8(%ebx),%eax
consume = MIN(remaining, todo);
105946: be 00 02 00 00 mov $0x200,%esi
10594b: 29 c6 sub %eax,%esi
10594d: 3b 75 10 cmp 0x10(%ebp),%esi
105950: 89 75 e4 mov %esi,-0x1c(%ebp)
105953: 0f 87 77 01 00 00 ja 105ad0 <Untar_FromChunk_Print+0x250>
memcpy(&context->header[context->done_bytes], &buf[done], consume);
105959: 8b 75 0c mov 0xc(%ebp),%esi
10595c: 8d 84 03 e8 00 00 00 lea 0xe8(%ebx,%eax,1),%eax
105963: 8b 55 e0 mov -0x20(%ebp),%edx
105966: 89 c7 mov %eax,%edi
105968: 8b 4d e4 mov -0x1c(%ebp),%ecx
10596b: 01 f2 add %esi,%edx
10596d: 83 f9 08 cmp $0x8,%ecx
105970: 89 d6 mov %edx,%esi
105972: 0f 83 78 01 00 00 jae 105af0 <Untar_FromChunk_Print+0x270> <== NEVER TAKEN
105978: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
context->done_bytes += consume;
10597a: 8b 8b e8 02 00 00 mov 0x2e8(%ebx),%ecx
105980: 8b 45 e4 mov -0x1c(%ebp),%eax
105983: 01 c8 add %ecx,%eax
105985: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx)
if (context->done_bytes == 512) {
10598b: 3d 00 02 00 00 cmp $0x200,%eax
105990: 75 8e jne 105920 <Untar_FromChunk_Print+0xa0>
ctx->file_name[0] = '\0';
105992: 8b 43 04 mov 0x4(%ebx),%eax
if (strncmp(&bufr[257], "ustar", 5)) {
105995: bf 73 8a 12 00 mov $0x128a73,%edi
10599a: b9 05 00 00 00 mov $0x5,%ecx
10599f: 8b 75 dc mov -0x24(%ebp),%esi
ctx->file_name[0] = '\0';
1059a2: c6 00 00 movb $0x0,(%eax)
ctx->file_size = 0;
1059a5: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
ctx->nblocks = 0;
1059ac: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
ctx->linkflag = -1;
1059b3: c6 43 78 ff movb $0xff,0x78(%ebx)
if (strncmp(&bufr[257], "ustar", 5)) {
1059b7: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
1059b9: 0f 97 c0 seta %al
1059bc: 1c 00 sbb $0x0,%al
1059be: 84 c0 test %al,%al
1059c0: 0f 85 db 00 00 00 jne 105aa1 <Untar_FromChunk_Print+0x221>
&context->header[0]
1059c6: 8d 93 e8 00 00 00 lea 0xe8(%ebx),%edx
1059cc: 89 d8 mov %ebx,%eax
1059ce: e8 cd f5 ff ff call 104fa0 <Untar_ProcessHeader.part.0>
if (retval != UNTAR_SUCCESSFUL) {
1059d3: 85 c0 test %eax,%eax
1059d5: 0f 85 82 01 00 00 jne 105b5d <Untar_FromChunk_Print+0x2dd> <== NEVER TAKEN
if (context->base.linkflag == REGTYPE) {
1059db: 80 7b 78 30 cmpb $0x30,0x78(%ebx)
1059df: 0f 85 bc 00 00 00 jne 105aa1 <Untar_FromChunk_Print+0x221>
context->out_fd = creat(context->base.file_path,
1059e5: 8b 43 6c mov 0x6c(%ebx),%eax
1059e8: 89 44 24 04 mov %eax,0x4(%esp)
1059ec: 8b 03 mov (%ebx),%eax
1059ee: 89 04 24 mov %eax,(%esp)
1059f1: e8 aa 79 01 00 call 11d3a0 <creat>
1059f6: 89 83 ec 02 00 00 mov %eax,0x2ec(%ebx)
if (context->out_fd >= 0) {
1059fc: 85 c0 test %eax,%eax
1059fe: 0f 88 38 01 00 00 js 105b3c <Untar_FromChunk_Print+0x2bc> <== NEVER TAKEN
context->state = UNTAR_CHUNK_WRITE;
105a04: b8 02 00 00 00 mov $0x2,%eax
105a09: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
context->done_bytes = 0;
105a0f: 31 c0 xor %eax,%eax
105a11: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx)
105a17: e9 04 ff ff ff jmp 105920 <Untar_FromChunk_Print+0xa0>
105a1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
remaining = context->base.file_size - context->done_bytes;
105a20: 8b 43 70 mov 0x70(%ebx),%eax
consume = MIN(remaining, todo);
105a23: 8b 93 e8 02 00 00 mov 0x2e8(%ebx),%edx
105a29: 29 d0 sub %edx,%eax
105a2b: 3b 45 10 cmp 0x10(%ebp),%eax
105a2e: 89 45 e4 mov %eax,-0x1c(%ebp)
105a31: 0f 87 89 00 00 00 ja 105ac0 <Untar_FromChunk_Print+0x240>
write(context->out_fd, &buf[done], consume);
105a37: 8b 45 e0 mov -0x20(%ebp),%eax
105a3a: 8b 7d 0c mov 0xc(%ebp),%edi
105a3d: 8b 75 e4 mov -0x1c(%ebp),%esi
105a40: 01 f8 add %edi,%eax
105a42: 89 74 24 08 mov %esi,0x8(%esp)
105a46: 89 44 24 04 mov %eax,0x4(%esp)
105a4a: 8b 83 ec 02 00 00 mov 0x2ec(%ebx),%eax
105a50: 89 04 24 mov %eax,(%esp)
105a53: e8 b8 d3 ff ff call 102e10 <write>
context->done_bytes += consume;
105a58: 8b 83 e8 02 00 00 mov 0x2e8(%ebx),%eax
105a5e: 01 f0 add %esi,%eax
if (context->done_bytes == context->base.file_size) {
105a60: 3b 43 70 cmp 0x70(%ebx),%eax
context->done_bytes += consume;
105a63: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx)
if (context->done_bytes == context->base.file_size) {
105a69: 0f 85 b1 fe ff ff jne 105920 <Untar_FromChunk_Print+0xa0>
close(context->out_fd);
105a6f: 8b 83 ec 02 00 00 mov 0x2ec(%ebx),%eax
105a75: 89 04 24 mov %eax,(%esp)
105a78: e8 13 b2 ff ff call 100c90 <close>
context->base.file_size = 512 * context->base.nblocks
105a7d: 8b 43 74 mov 0x74(%ebx),%eax
context->out_fd = -1;
105a80: ba ff ff ff ff mov $0xffffffff,%edx
105a85: 89 93 ec 02 00 00 mov %edx,0x2ec(%ebx)
- context->base.file_size;
105a8b: 8b 73 70 mov 0x70(%ebx),%esi
context->state = UNTAR_CHUNK_SKIP;
105a8e: b9 01 00 00 00 mov $0x1,%ecx
105a93: 89 8b e4 00 00 00 mov %ecx,0xe4(%ebx)
context->base.file_size = 512 * context->base.nblocks
105a99: c1 e0 09 shl $0x9,%eax
- context->base.file_size;
105a9c: 29 f0 sub %esi,%eax
context->base.file_size = 512 * context->base.nblocks
105a9e: 89 43 70 mov %eax,0x70(%ebx)
done += consume;
105aa1: 8b 4d e4 mov -0x1c(%ebp),%ecx
context->done_bytes = 0;
105aa4: 31 c0 xor %eax,%eax
done += consume;
105aa6: 01 4d e0 add %ecx,-0x20(%ebp)
while (todo > 0) {
105aa9: 29 4d 10 sub %ecx,0x10(%ebp)
context->done_bytes = 0;
105aac: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx)
while (todo > 0) {
105ab2: 0f 85 f5 fd ff ff jne 1058ad <Untar_FromChunk_Print+0x2d> <== NEVER TAKEN
105ab8: e9 6e fe ff ff jmp 10592b <Untar_FromChunk_Print+0xab>
105abd: 8d 76 00 lea 0x0(%esi),%esi
consume = MIN(remaining, todo);
105ac0: 8b 45 10 mov 0x10(%ebp),%eax
105ac3: 89 45 e4 mov %eax,-0x1c(%ebp)
105ac6: e9 6c ff ff ff jmp 105a37 <Untar_FromChunk_Print+0x1b7>
105acb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105acf: 90 nop
consume = MIN(remaining, todo);
105ad0: 8b 55 10 mov 0x10(%ebp),%edx
105ad3: 89 55 e4 mov %edx,-0x1c(%ebp)
105ad6: e9 7e fe ff ff jmp 105959 <Untar_FromChunk_Print+0xd9>
105adb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105adf: 90 nop
consume = MIN(remaining, todo);
105ae0: 8b 7d 10 mov 0x10(%ebp),%edi
105ae3: 89 7d e4 mov %edi,-0x1c(%ebp)
105ae6: e9 0e fe ff ff jmp 1058f9 <Untar_FromChunk_Print+0x79>
105aeb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105aef: 90 nop
memcpy(&context->header[context->done_bytes], &buf[done], consume);
105af0: a8 01 test $0x1,%al <== NOT EXECUTED
105af2: 75 27 jne 105b1b <Untar_FromChunk_Print+0x29b> <== NOT EXECUTED
105af4: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
105afa: 75 2e jne 105b2a <Untar_FromChunk_Print+0x2aa> <== NOT EXECUTED
105afc: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
105b02: 0f 84 70 fe ff ff je 105978 <Untar_FromChunk_Print+0xf8> <== NOT EXECUTED
105b08: 8b 06 mov (%esi),%eax <== NOT EXECUTED
105b0a: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
105b0d: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
105b10: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
105b13: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED
105b16: e9 5d fe ff ff jmp 105978 <Untar_FromChunk_Print+0xf8> <== NOT EXECUTED
105b1b: 0f b6 0a movzbl (%edx),%ecx <== NOT EXECUTED
105b1e: 47 inc %edi <== NOT EXECUTED
105b1f: 46 inc %esi <== NOT EXECUTED
105b20: 88 08 mov %cl,(%eax) <== NOT EXECUTED
105b22: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
105b25: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED
105b28: eb ca jmp 105af4 <Untar_FromChunk_Print+0x274> <== NOT EXECUTED
105b2a: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
105b2d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
105b30: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
105b33: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
105b36: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
105b3a: eb c0 jmp 105afc <Untar_FromChunk_Print+0x27c> <== NOT EXECUTED
context->state = UNTAR_CHUNK_SKIP;
105b3c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
105b41: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx) <== NOT EXECUTED
context->base.file_size = 512 * context->base.nblocks;
105b47: 8b 43 74 mov 0x74(%ebx),%eax <== NOT EXECUTED
105b4a: c1 e0 09 shl $0x9,%eax <== NOT EXECUTED
105b4d: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED
context->done_bytes = 0;
105b50: 31 c0 xor %eax,%eax <== NOT EXECUTED
105b52: 89 83 e8 02 00 00 mov %eax,0x2e8(%ebx) <== NOT EXECUTED
105b58: e9 c3 fd ff ff jmp 105920 <Untar_FromChunk_Print+0xa0> <== NOT EXECUTED
context->state = UNTAR_CHUNK_ERROR;
105b5d: ba 03 00 00 00 mov $0x3,%edx <== NOT EXECUTED
105b62: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) <== NOT EXECUTED
return retval;
105b68: e9 5d fd ff ff jmp 1058ca <Untar_FromChunk_Print+0x4a> <== NOT EXECUTED
105b6d: 90 nop
105b6e: 90 nop
105b6f: 90 nop
00105680 <Untar_FromFile_Print>:
{
105680: 55 push %ebp
if ((fd = open(tar_name, O_RDONLY)) < 0) {
105681: 31 c0 xor %eax,%eax
{
105683: 89 e5 mov %esp,%ebp
105685: 57 push %edi
return UNTAR_FAIL;
105686: bf 01 00 00 00 mov $0x1,%edi
{
10568b: 56 push %esi
10568c: 53 push %ebx
10568d: 81 ec 1c 01 00 00 sub $0x11c,%esp
if ((fd = open(tar_name, O_RDONLY)) < 0) {
105693: 89 44 24 04 mov %eax,0x4(%esp)
105697: 8b 45 08 mov 0x8(%ebp),%eax
10569a: 89 04 24 mov %eax,(%esp)
10569d: e8 1e c3 ff ff call 1019c0 <open>
1056a2: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp)
1056a8: 85 c0 test %eax,%eax
1056aa: 0f 88 48 01 00 00 js 1057f8 <Untar_FromFile_Print+0x178> <== NEVER TAKEN
bufr = (char *)malloc(512);
1056b0: c7 04 24 00 02 00 00 movl $0x200,(%esp)
1056b7: e8 14 4e 00 00 call 10a4d0 <malloc>
if (bufr == NULL) {
1056bc: 85 c0 test %eax,%eax
bufr = (char *)malloc(512);
1056be: 89 c3 mov %eax,%ebx
if (bufr == NULL) {
1056c0: 0f 84 24 01 00 00 je 1057ea <Untar_FromFile_Print+0x16a> <== NEVER TAKEN
ctx.file_path = buf;
1056c6: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax
1056cc: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
ctx.file_name = buf;
1056d2: 89 85 6c ff ff ff mov %eax,-0x94(%ebp)
ctx.printer = printer;
1056d8: 8b 45 0c mov 0xc(%ebp),%eax
1056db: 89 45 e4 mov %eax,-0x1c(%ebp)
if (strncmp(&bufr[257], "ustar", 5)) {
1056de: 8d 83 01 01 00 00 lea 0x101(%ebx),%eax
1056e4: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp)
1056ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if ((n = read(fd, bufr, 512)) != 512) {
1056f0: 89 5c 24 04 mov %ebx,0x4(%esp)
1056f4: b8 00 02 00 00 mov $0x200,%eax
1056f9: 89 44 24 08 mov %eax,0x8(%esp)
1056fd: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax
105703: 89 04 24 mov %eax,(%esp)
105706: e8 f5 c6 ff ff call 101e00 <read>
10570b: 3d 00 02 00 00 cmp $0x200,%eax
105710: 0f 85 fa 00 00 00 jne 105810 <Untar_FromFile_Print+0x190>
ctx->file_name[0] = '\0';
105716: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax
if (strncmp(&bufr[257], "ustar", 5)) {
10571c: bf 73 8a 12 00 mov $0x128a73,%edi
105721: b9 05 00 00 00 mov $0x5,%ecx
105726: 8b b5 f0 fe ff ff mov -0x110(%ebp),%esi
ctx->file_name[0] = '\0';
10572c: c6 00 00 movb $0x0,(%eax)
if (strncmp(&bufr[257], "ustar", 5)) {
10572f: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
ctx->file_size = 0;
105731: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
ctx->nblocks = 0;
105738: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
ctx->linkflag = -1;
10573f: c6 45 e0 ff movb $0xff,-0x20(%ebp)
if (strncmp(&bufr[257], "ustar", 5)) {
105743: 0f 97 c0 seta %al
105746: 1c 00 sbb $0x0,%al
105748: 84 c0 test %al,%al
10574a: 75 a4 jne 1056f0 <Untar_FromFile_Print+0x70>
10574c: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
105752: 89 da mov %ebx,%edx
105754: e8 47 f8 ff ff call 104fa0 <Untar_ProcessHeader.part.0>
if (retval != UNTAR_SUCCESSFUL)
105759: 85 c0 test %eax,%eax
10575b: 0f 85 7f 00 00 00 jne 1057e0 <Untar_FromFile_Print+0x160> <== NEVER TAKEN
if (ctx.linkflag == REGTYPE) {
105761: 80 7d e0 30 cmpb $0x30,-0x20(%ebp)
105765: 75 89 jne 1056f0 <Untar_FromFile_Print+0x70>
if ((out_fd = creat(ctx.file_path, ctx.mode)) == -1) {
105767: 8b 45 d4 mov -0x2c(%ebp),%eax
10576a: 89 44 24 04 mov %eax,0x4(%esp)
10576e: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
105774: 89 04 24 mov %eax,(%esp)
105777: e8 24 7c 01 00 call 11d3a0 <creat>
10577c: 83 f8 ff cmp $0xffffffff,%eax
10577f: 89 c7 mov %eax,%edi
105781: 0f 84 99 00 00 00 je 105820 <Untar_FromFile_Print+0x1a0> <== NEVER TAKEN
for (i = 0; i < ctx.nblocks; i++) {
105787: 8b 45 dc mov -0x24(%ebp),%eax
10578a: 31 f6 xor %esi,%esi
10578c: 85 c0 test %eax,%eax
10578e: 74 43 je 1057d3 <Untar_FromFile_Print+0x153> <== NEVER TAKEN
n = read(fd, bufr, 512);
105790: 89 5c 24 04 mov %ebx,0x4(%esp)
105794: b8 00 02 00 00 mov $0x200,%eax
105799: 89 44 24 08 mov %eax,0x8(%esp)
10579d: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax
1057a3: 89 04 24 mov %eax,(%esp)
1057a6: e8 55 c6 ff ff call 101e00 <read>
n = MIN(n, ctx.file_size - (i * 512UL));
1057ab: 89 f1 mov %esi,%ecx
1057ad: c1 e1 09 shl $0x9,%ecx
n = read(fd, bufr, 512);
1057b0: 89 c2 mov %eax,%edx
n = MIN(n, ctx.file_size - (i * 512UL));
1057b2: 8b 45 d8 mov -0x28(%ebp),%eax
1057b5: 29 c8 sub %ecx,%eax
1057b7: 39 d0 cmp %edx,%eax
1057b9: 76 02 jbe 1057bd <Untar_FromFile_Print+0x13d> <== ALWAYS TAKEN
1057bb: 89 d0 mov %edx,%eax <== NOT EXECUTED
(void) write(out_fd, bufr, n);
1057bd: 89 44 24 08 mov %eax,0x8(%esp)
for (i = 0; i < ctx.nblocks; i++) {
1057c1: 46 inc %esi
(void) write(out_fd, bufr, n);
1057c2: 89 5c 24 04 mov %ebx,0x4(%esp)
1057c6: 89 3c 24 mov %edi,(%esp)
1057c9: e8 42 d6 ff ff call 102e10 <write>
for (i = 0; i < ctx.nblocks; i++) {
1057ce: 39 75 dc cmp %esi,-0x24(%ebp)
1057d1: 77 bd ja 105790 <Untar_FromFile_Print+0x110> <== NEVER TAKEN
close(out_fd);
1057d3: 89 3c 24 mov %edi,(%esp)
1057d6: e8 b5 b4 ff ff call 100c90 <close>
1057db: e9 10 ff ff ff jmp 1056f0 <Untar_FromFile_Print+0x70>
1057e0: 89 c7 mov %eax,%edi <== NOT EXECUTED
free(bufr);
1057e2: 89 1c 24 mov %ebx,(%esp)
1057e5: e8 96 4a 00 00 call 10a280 <free>
close(fd);
1057ea: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax
1057f0: 89 04 24 mov %eax,(%esp)
1057f3: e8 98 b4 ff ff call 100c90 <close>
}
1057f8: 81 c4 1c 01 00 00 add $0x11c,%esp
1057fe: 89 f8 mov %edi,%eax
105800: 5b pop %ebx
105801: 5e pop %esi
105802: 5f pop %edi
105803: 5d pop %ebp
105804: c3 ret
105805: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10580c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
105810: 31 ff xor %edi,%edi
105812: eb ce jmp 1057e2 <Untar_FromFile_Print+0x162>
105814: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10581b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10581f: 90 nop
(void) lseek(fd, SEEK_CUR, 512UL * ctx.nblocks);
105820: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
105823: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
105825: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
10582a: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10582e: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
105832: c1 e0 09 shl $0x9,%eax <== NOT EXECUTED
105835: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
105839: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax <== NOT EXECUTED
10583f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105842: e8 49 b8 ff ff call 101090 <lseek> <== NOT EXECUTED
105847: e9 a4 fe ff ff jmp 1056f0 <Untar_FromFile_Print+0x70> <== NOT EXECUTED
10584c: 90 nop
10584d: 90 nop
10584e: 90 nop
10584f: 90 nop
00105c80 <Untar_FromGzChunk_Print>:
Untar_GzChunkContext *ctx,
void *chunk,
size_t chunk_size,
const rtems_printer *printer
)
{
105c80: 55 push %ebp
105c81: 89 e5 mov %esp,%ebp
105c83: 57 push %edi
105c84: 56 push %esi
105c85: 53 push %ebx
105c86: 83 ec 2c sub $0x2c,%esp
105c89: 8b 5d 08 mov 0x8(%ebp),%ebx
int untar_succesful;
int status;
ctx->strm.next_in = (Bytef *)chunk;
105c8c: 8b 45 0c mov 0xc(%ebp),%eax
/* Inflate until output buffer is not full */
do {
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
ctx->strm.avail_out = ctx->inflateBufferSize;
status = inflate(&ctx->strm, Z_NO_FLUSH);
105c8f: 8d bb f0 02 00 00 lea 0x2f0(%ebx),%edi
ctx->strm.next_in = (Bytef *)chunk;
105c95: 89 83 f0 02 00 00 mov %eax,0x2f0(%ebx)
ctx->strm.avail_in = (size_t)chunk_size;
105c9b: 8b 45 10 mov 0x10(%ebp),%eax
105c9e: 89 83 f4 02 00 00 mov %eax,0x2f4(%ebx)
105ca4: eb 26 jmp 105ccc <Untar_FromGzChunk_Print+0x4c>
105ca6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105cad: 8d 76 00 lea 0x0(%esi),%esi
}
} else {
untar_succesful = UNTAR_GZ_INFLATE_FAILED;
}
} while (ctx->strm.avail_out == 0 && ctx->strm.avail_in > 0
&& status == Z_OK);
105cb0: 8b 83 00 03 00 00 mov 0x300(%ebx),%eax
105cb6: 85 c0 test %eax,%eax
105cb8: 0f 85 82 00 00 00 jne 105d40 <Untar_FromGzChunk_Print+0xc0>
} while (ctx->strm.avail_out == 0 && ctx->strm.avail_in > 0
105cbe: 8b 83 f4 02 00 00 mov 0x2f4(%ebx),%eax
105cc4: 85 c0 test %eax,%eax
105cc6: 74 78 je 105d40 <Untar_FromGzChunk_Print+0xc0>
&& status == Z_OK);
105cc8: 85 f6 test %esi,%esi
105cca: 75 78 jne 105d44 <Untar_FromGzChunk_Print+0xc4> <== NEVER TAKEN
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
105ccc: 8b 83 28 03 00 00 mov 0x328(%ebx),%eax
status = inflate(&ctx->strm, Z_NO_FLUSH);
105cd2: 31 c9 xor %ecx,%ecx
ctx->strm.next_out = (Bytef *) ctx->inflateBuffer;
105cd4: 89 83 fc 02 00 00 mov %eax,0x2fc(%ebx)
ctx->strm.avail_out = ctx->inflateBufferSize;
105cda: 8b 83 2c 03 00 00 mov 0x32c(%ebx),%eax
105ce0: 89 83 00 03 00 00 mov %eax,0x300(%ebx)
status = inflate(&ctx->strm, Z_NO_FLUSH);
105ce6: 89 4c 24 04 mov %ecx,0x4(%esp)
105cea: 89 3c 24 mov %edi,(%esp)
105ced: e8 de 2e 01 00 call 118bd0 <z_inflate>
untar_succesful = UNTAR_GZ_INFLATE_FAILED;
105cf2: ba 04 00 00 00 mov $0x4,%edx
if (status == Z_OK || status == Z_STREAM_END) {
105cf7: 83 f8 01 cmp $0x1,%eax
status = inflate(&ctx->strm, Z_NO_FLUSH);
105cfa: 89 c6 mov %eax,%esi
if (status == Z_OK || status == Z_STREAM_END) {
105cfc: 77 b2 ja 105cb0 <Untar_FromGzChunk_Print+0x30> <== NEVER TAKEN
untar_succesful = Untar_FromChunk_Print(&ctx->base,
105cfe: 31 c0 xor %eax,%eax
105d00: 89 44 24 0c mov %eax,0xc(%esp)
size_t inflated_size =
105d04: 8b 93 00 03 00 00 mov 0x300(%ebx),%edx
105d0a: 8b 83 2c 03 00 00 mov 0x32c(%ebx),%eax
105d10: 29 d0 sub %edx,%eax
untar_succesful = Untar_FromChunk_Print(&ctx->base,
105d12: 89 44 24 08 mov %eax,0x8(%esp)
105d16: 8b 83 28 03 00 00 mov 0x328(%ebx),%eax
105d1c: 89 1c 24 mov %ebx,(%esp)
105d1f: 89 44 24 04 mov %eax,0x4(%esp)
105d23: e8 58 fb ff ff call 105880 <Untar_FromChunk_Print>
if (untar_succesful != UNTAR_SUCCESSFUL){
105d28: 85 c0 test %eax,%eax
untar_succesful = Untar_FromChunk_Print(&ctx->base,
105d2a: 89 c2 mov %eax,%edx
if (untar_succesful != UNTAR_SUCCESSFUL){
105d2c: 74 82 je 105cb0 <Untar_FromGzChunk_Print+0x30> <== ALWAYS TAKEN
if (status != Z_OK) {
rtems_printf(printer, "Zlib inflate end failed\n");
}
}
return untar_succesful;
}
105d2e: 83 c4 2c add $0x2c,%esp
105d31: 89 d0 mov %edx,%eax
105d33: 5b pop %ebx
105d34: 5e pop %esi
105d35: 5f pop %edi
105d36: 5d pop %ebp
105d37: c3 ret
105d38: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105d3f: 90 nop
if (status != Z_OK) {
105d40: 85 f6 test %esi,%esi
105d42: 74 ea je 105d2e <Untar_FromGzChunk_Print+0xae>
if (untar_succesful != UNTAR_SUCCESSFUL){
105d44: 85 d2 test %edx,%edx
105d46: 75 58 jne 105da0 <Untar_FromGzChunk_Print+0x120> <== NEVER TAKEN
if (status != Z_STREAM_END) {
105d48: 4e dec %esi
105d49: 74 1a je 105d65 <Untar_FromGzChunk_Print+0xe5> <== ALWAYS TAKEN
105d4b: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
rtems_printf(printer, "Zlib inflate failed\n");
105d4e: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
105d51: ba bb 8a 12 00 mov $0x128abb,%edx <== NOT EXECUTED
105d56: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
105d5a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105d5d: e8 6e 49 00 00 call 10a6d0 <rtems_printf> <== NOT EXECUTED
105d62: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
status = inflateEnd(&ctx->strm);
105d65: 89 3c 24 mov %edi,(%esp)
105d68: 89 55 e4 mov %edx,-0x1c(%ebp)
105d6b: e8 10 4e 01 00 call 11ab80 <z_inflateEnd>
if (status != Z_OK) {
105d70: 8b 55 e4 mov -0x1c(%ebp),%edx
105d73: 85 c0 test %eax,%eax
105d75: 74 b7 je 105d2e <Untar_FromGzChunk_Print+0xae> <== ALWAYS TAKEN
rtems_printf(printer, "Zlib inflate end failed\n");
105d77: b8 d0 8a 12 00 mov $0x128ad0,%eax <== NOT EXECUTED
105d7c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
105d80: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
105d83: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105d86: e8 45 49 00 00 call 10a6d0 <rtems_printf> <== NOT EXECUTED
105d8b: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
}
105d8e: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
105d91: 5b pop %ebx <== NOT EXECUTED
105d92: 5e pop %esi <== NOT EXECUTED
105d93: 89 d0 mov %edx,%eax <== NOT EXECUTED
105d95: 5f pop %edi <== NOT EXECUTED
105d96: 5d pop %ebp <== NOT EXECUTED
105d97: c3 ret <== NOT EXECUTED
105d98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105d9f: 90 nop <== NOT EXECUTED
105da0: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
rtems_printf(printer, "Untar not successful\n");
105da3: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
105da6: b9 a5 8a 12 00 mov $0x128aa5,%ecx <== NOT EXECUTED
105dab: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
105daf: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105db2: e8 19 49 00 00 call 10a6d0 <rtems_printf> <== NOT EXECUTED
105db7: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
105dba: eb 8c jmp 105d48 <Untar_FromGzChunk_Print+0xc8> <== NOT EXECUTED
105dbc: 90 nop
105dbd: 90 nop
105dbe: 90 nop
105dbf: 90 nop
00105410 <Untar_FromMemory_Print>:
{
105410: 55 push %ebp
105411: 89 e5 mov %esp,%ebp
105413: 57 push %edi
105414: 56 push %esi
105415: 53 push %ebx
ctx.file_path = buf;
105416: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax
{
10541c: 81 ec 2c 01 00 00 sub $0x12c,%esp
ctx.file_path = buf;
105422: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
ctx.file_name = buf;
105428: 89 85 6c ff ff ff mov %eax,-0x94(%ebp)
ctx.printer = printer;
10542e: 8b 45 10 mov 0x10(%ebp),%eax
105431: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_printf(printer, "untar: memory at %p (%zu)\n", tar_buf, size);
105434: 8b 45 0c mov 0xc(%ebp),%eax
105437: 89 44 24 0c mov %eax,0xc(%esp)
10543b: 8b 45 08 mov 0x8(%ebp),%eax
10543e: 89 44 24 08 mov %eax,0x8(%esp)
105442: b8 79 8a 12 00 mov $0x128a79,%eax
105447: 89 44 24 04 mov %eax,0x4(%esp)
10544b: 8b 45 10 mov 0x10(%ebp),%eax
10544e: 89 04 24 mov %eax,(%esp)
105451: e8 7a 52 00 00 call 10a6d0 <rtems_printf>
ptr = 0;
105456: 31 c0 xor %eax,%eax
105458: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp)
10545e: 8b 45 08 mov 0x8(%ebp),%eax
105461: 8b 8d f4 fe ff ff mov -0x10c(%ebp),%ecx
105467: 8d 9c 08 01 01 00 00 lea 0x101(%eax,%ecx,1),%ebx
10546e: eb 10 jmp 105480 <Untar_FromMemory_Print+0x70>
if (ctx.linkflag == REGTYPE) {
105470: 80 7d e0 30 cmpb $0x30,-0x20(%ebp)
105474: 0f 84 86 00 00 00 je 105500 <Untar_FromMemory_Print+0xf0>
10547a: 81 c3 00 02 00 00 add $0x200,%ebx
if (ptr + 512 > size) {
105480: 81 85 f4 fe ff ff 00 addl $0x200,-0x10c(%ebp)
105487: 02 00 00
10548a: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax
105490: 3b 45 0c cmp 0xc(%ebp),%eax
105493: 77 5b ja 1054f0 <Untar_FromMemory_Print+0xe0>
ctx->file_name[0] = '\0';
105495: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax
if (strncmp(&bufr[257], "ustar", 5)) {
10549b: bf 73 8a 12 00 mov $0x128a73,%edi
1054a0: b9 05 00 00 00 mov $0x5,%ecx
1054a5: 8d 93 ff fe ff ff lea -0x101(%ebx),%edx
1054ab: 89 de mov %ebx,%esi
ctx->file_name[0] = '\0';
1054ad: c6 00 00 movb $0x0,(%eax)
if (strncmp(&bufr[257], "ustar", 5)) {
1054b0: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
ctx->file_size = 0;
1054b2: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
ctx->nblocks = 0;
1054b9: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
ctx->linkflag = -1;
1054c0: c6 45 e0 ff movb $0xff,-0x20(%ebp)
if (strncmp(&bufr[257], "ustar", 5)) {
1054c4: 0f 97 c0 seta %al
1054c7: 1c 00 sbb $0x0,%al
1054c9: 84 c0 test %al,%al
1054cb: 75 ad jne 10547a <Untar_FromMemory_Print+0x6a>
1054cd: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
1054d3: e8 c8 fa ff ff call 104fa0 <Untar_ProcessHeader.part.0>
if (retval != UNTAR_SUCCESSFUL)
1054d8: 85 c0 test %eax,%eax
1054da: 74 94 je 105470 <Untar_FromMemory_Print+0x60> <== ALWAYS TAKEN
}
1054dc: 81 c4 2c 01 00 00 add $0x12c,%esp <== NOT EXECUTED
1054e2: 89 c6 mov %eax,%esi <== NOT EXECUTED
1054e4: 5b pop %ebx <== NOT EXECUTED
1054e5: 89 f0 mov %esi,%eax <== NOT EXECUTED
1054e7: 5e pop %esi <== NOT EXECUTED
1054e8: 5f pop %edi <== NOT EXECUTED
1054e9: 5d pop %ebp <== NOT EXECUTED
1054ea: c3 ret <== NOT EXECUTED
1054eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1054ef: 90 nop <== NOT EXECUTED
1054f0: 81 c4 2c 01 00 00 add $0x12c,%esp
retval = UNTAR_SUCCESSFUL;
1054f6: 31 f6 xor %esi,%esi
}
1054f8: 5b pop %ebx
1054f9: 89 f0 mov %esi,%eax
1054fb: 5e pop %esi
1054fc: 5f pop %edi
1054fd: 5d pop %ebp
1054fe: c3 ret
1054ff: 90 nop
if ((fd = open(ctx.file_path,
105500: 89 c6 mov %eax,%esi
105502: 8b 45 d4 mov -0x2c(%ebp),%eax
105505: bf 01 06 00 00 mov $0x601,%edi
10550a: 89 7c 24 04 mov %edi,0x4(%esp)
10550e: 89 44 24 08 mov %eax,0x8(%esp)
105512: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax
105518: 89 04 24 mov %eax,(%esp)
10551b: e8 a0 c4 ff ff call 1019c0 <open>
105520: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp)
105526: 40 inc %eax
105527: 0f 84 d3 00 00 00 je 105600 <Untar_FromMemory_Print+0x1f0> <== NEVER TAKEN
for (i = 0; i < ctx.nblocks; i++) {
10552d: 8b 4d dc mov -0x24(%ebp),%ecx
unsigned long sizeToGo = ctx.file_size;
105530: 8b 5d d8 mov -0x28(%ebp),%ebx
for (i = 0; i < ctx.nblocks; i++) {
105533: 85 c9 test %ecx,%ecx
105535: 0f 84 b0 00 00 00 je 1055eb <Untar_FromMemory_Print+0x1db> <== NEVER TAKEN
10553b: 89 f2 mov %esi,%edx
10553d: 89 de mov %ebx,%esi
10553f: 8b 9d f4 fe ff ff mov -0x10c(%ebp),%ebx
105545: eb 15 jmp 10555c <Untar_FromMemory_Print+0x14c>
105547: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10554e: 66 90 xchg %ax,%ax
105550: 42 inc %edx
sizeToGo -= n;
105551: 29 fe sub %edi,%esi
for (i = 0; i < ctx.nblocks; i++) {
105553: 39 55 dc cmp %edx,-0x24(%ebp)
105556: 0f 86 fc 00 00 00 jbe 105658 <Untar_FromMemory_Print+0x248> <== ALWAYS TAKEN
len = ((sizeToGo < 512L) ? (sizeToGo) : (512L));
10555c: 81 fe 00 02 00 00 cmp $0x200,%esi
105562: 89 f7 mov %esi,%edi
105564: 76 05 jbe 10556b <Untar_FromMemory_Print+0x15b> <== ALWAYS TAKEN
105566: bf 00 02 00 00 mov $0x200,%edi <== NOT EXECUTED
n = write(fd, &tar_ptr[ptr], len);
10556b: 89 7c 24 08 mov %edi,0x8(%esp)
10556f: 8b 45 08 mov 0x8(%ebp),%eax
105572: 89 95 f4 fe ff ff mov %edx,-0x10c(%ebp)
105578: 01 d8 add %ebx,%eax
10557a: 89 44 24 04 mov %eax,0x4(%esp)
10557e: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
105584: 89 04 24 mov %eax,(%esp)
105587: e8 84 d8 ff ff call 102e10 <write>
if (n != len) {
10558c: 89 d9 mov %ebx,%ecx
ptr += 512;
10558e: 81 c3 00 02 00 00 add $0x200,%ebx
if (n != len) {
105594: 8b 95 f4 fe ff ff mov -0x10c(%ebp),%edx
10559a: 39 c7 cmp %eax,%edi
10559c: 74 b2 je 105550 <Untar_FromMemory_Print+0x140> <== ALWAYS TAKEN
Print_Error(printer, "write", ctx.file_path);
10559e: 89 8d f4 fe ff ff mov %ecx,-0x10c(%ebp) <== NOT EXECUTED
1055a4: 8b bd 68 ff ff ff mov -0x98(%ebp),%edi <== NOT EXECUTED
message, path, errno, strerror(errno));
1055aa: e8 11 7e 01 00 call 11d3c0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
1055af: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1055b1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1055b4: e8 e7 8b 01 00 call 11e1a0 <strerror> <== NOT EXECUTED
1055b9: 89 c6 mov %eax,%esi <== NOT EXECUTED
message, path, errno, strerror(errno));
1055bb: e8 00 7e 01 00 call 11d3c0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
1055c0: ba 1c 8a 12 00 mov $0x128a1c,%edx <== NOT EXECUTED
1055c5: 89 74 24 14 mov %esi,0x14(%esp) <== NOT EXECUTED
1055c9: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1055cb: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
1055cf: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
1055d3: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
1055d7: b8 99 8a 12 00 mov $0x128a99,%eax <== NOT EXECUTED
1055dc: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1055e0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
1055e3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1055e6: e8 e5 50 00 00 call 10a6d0 <rtems_printf> <== NOT EXECUTED
close(fd);
1055eb: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax <== NOT EXECUTED
1055f1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1055f4: e8 97 b6 ff ff call 100c90 <close> <== NOT EXECUTED
1055f9: e9 60 fe ff ff jmp 10545e <Untar_FromMemory_Print+0x4e> <== NOT EXECUTED
1055fe: 66 90 xchg %ax,%ax <== NOT EXECUTED
Print_Error(printer, "open", ctx.file_path);
105600: 8b b5 68 ff ff ff mov -0x98(%ebp),%esi <== NOT EXECUTED
message, path, errno, strerror(errno));
105606: e8 b5 7d 01 00 call 11d3c0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
10560b: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10560d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105610: e8 8b 8b 01 00 call 11e1a0 <strerror> <== NOT EXECUTED
105615: 89 c3 mov %eax,%ebx <== NOT EXECUTED
message, path, errno, strerror(errno));
105617: e8 a4 7d 01 00 call 11d3c0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
10561c: 89 5c 24 14 mov %ebx,0x14(%esp) <== NOT EXECUTED
105620: bb 94 8a 12 00 mov $0x128a94,%ebx <== NOT EXECUTED
105625: 8b 00 mov (%eax),%eax <== NOT EXECUTED
105627: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
10562b: be 1c 8a 12 00 mov $0x128a1c,%esi <== NOT EXECUTED
105630: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
105634: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
105638: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10563c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10563f: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105642: e8 89 50 00 00 call 10a6d0 <rtems_printf> <== NOT EXECUTED
ptr += 512 * ctx.nblocks;
105647: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
10564a: c1 e0 09 shl $0x9,%eax <== NOT EXECUTED
10564d: 01 85 f4 fe ff ff add %eax,-0x10c(%ebp) <== NOT EXECUTED
105653: e9 06 fe ff ff jmp 10545e <Untar_FromMemory_Print+0x4e> <== NOT EXECUTED
105658: 89 9d f4 fe ff ff mov %ebx,-0x10c(%ebp)
close(fd);
10565e: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
105664: 89 04 24 mov %eax,(%esp)
105667: e8 24 b6 ff ff call 100c90 <close>
10566c: e9 ed fd ff ff jmp 10545e <Untar_FromMemory_Print+0x4e>
105671: 90 nop
105672: 90 nop
105673: 90 nop
105674: 90 nop
105675: 90 nop
105676: 90 nop
105677: 90 nop
105678: 90 nop
105679: 90 nop
10567a: 90 nop
10567b: 90 nop
10567c: 90 nop
10567d: 90 nop
10567e: 90 nop
10567f: 90 nop
00105b90 <Untar_GzChunkContext_Init>:
int Untar_GzChunkContext_Init(
Untar_GzChunkContext *ctx,
void *inflateBuffer,
size_t inflateBufferSize
)
{
105b90: 55 push %ebp
105b91: 89 e5 mov %esp,%ebp
105b93: 57 push %edi
int status = UNTAR_SUCCESSFUL;
Untar_ChunkContext_Init(&ctx->base);
ctx->inflateBuffer = inflateBuffer;
ctx->inflateBufferSize = inflateBufferSize;
memset(&ctx->strm, 0, sizeof(ctx->strm));
105b94: 31 ff xor %edi,%edi
{
105b96: 56 push %esi
105b97: 53 push %ebx
105b98: 83 ec 1c sub $0x1c,%esp
105b9b: 8b 5d 08 mov 0x8(%ebp),%ebx
Untar_ChunkContext_Init(&ctx->base);
105b9e: 89 1c 24 mov %ebx,(%esp)
memset(&ctx->strm, 0, sizeof(ctx->strm));
105ba1: 8d b3 f0 02 00 00 lea 0x2f0(%ebx),%esi
Untar_ChunkContext_Init(&ctx->base);
105ba7: e8 a4 fc ff ff call 105850 <Untar_ChunkContext_Init>
ctx->inflateBuffer = inflateBuffer;
105bac: 8b 45 0c mov 0xc(%ebp),%eax
memset(&ctx->strm, 0, sizeof(ctx->strm));
105baf: f7 c6 01 00 00 00 test $0x1,%esi
105bb5: b9 38 00 00 00 mov $0x38,%ecx
ctx->inflateBuffer = inflateBuffer;
105bba: 89 83 28 03 00 00 mov %eax,0x328(%ebx)
ctx->inflateBufferSize = inflateBufferSize;
105bc0: 8b 45 10 mov 0x10(%ebp),%eax
105bc3: 89 83 2c 03 00 00 mov %eax,0x32c(%ebx)
memset(&ctx->strm, 0, sizeof(ctx->strm));
105bc9: 89 f0 mov %esi,%eax
105bcb: 0f 85 8f 00 00 00 jne 105c60 <Untar_GzChunkContext_Init+0xd0> <== NEVER TAKEN
105bd1: a8 02 test $0x2,%al
105bd3: 75 7b jne 105c50 <Untar_GzChunkContext_Init+0xc0> <== NEVER TAKEN
105bd5: 89 cb mov %ecx,%ebx
105bd7: 31 d2 xor %edx,%edx
105bd9: 83 e3 f8 and $0xfffffff8,%ebx
105bdc: 89 3c 10 mov %edi,(%eax,%edx,1)
105bdf: 89 7c 10 04 mov %edi,0x4(%eax,%edx,1)
105be3: 83 c2 08 add $0x8,%edx
105be6: 39 da cmp %ebx,%edx
105be8: 72 f2 jb 105bdc <Untar_GzChunkContext_Init+0x4c>
105bea: 01 d0 add %edx,%eax
105bec: f6 c1 04 test $0x4,%cl
105bef: 74 09 je 105bfa <Untar_GzChunkContext_Init+0x6a> <== ALWAYS TAKEN
105bf1: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
105bf7: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
105bfa: f6 c1 02 test $0x2,%cl
105bfd: 74 08 je 105c07 <Untar_GzChunkContext_Init+0x77> <== ALWAYS TAKEN
105bff: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
105c04: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
105c07: f6 c1 01 test $0x1,%cl
105c0a: 74 03 je 105c0f <Untar_GzChunkContext_Init+0x7f> <== ALWAYS TAKEN
105c0c: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
ret = inflateInit2(&ctx->strm, 32 + MAX_WBITS);
105c0f: b8 38 00 00 00 mov $0x38,%eax
105c14: ba 9f 8a 12 00 mov $0x128a9f,%edx
105c19: 89 34 24 mov %esi,(%esp)
105c1c: b9 2f 00 00 00 mov $0x2f,%ecx
105c21: 89 44 24 0c mov %eax,0xc(%esp)
105c25: 89 54 24 08 mov %edx,0x8(%esp)
105c29: 89 4c 24 04 mov %ecx,0x4(%esp)
105c2d: e8 9e 2e 01 00 call 118ad0 <z_inflateInit2_>
if (ret != Z_OK){
105c32: 85 c0 test %eax,%eax
105c34: 0f 95 c0 setne %al
status = UNTAR_FAIL;
}
return status;
}
105c37: 83 c4 1c add $0x1c,%esp
105c3a: 5b pop %ebx
if (ret != Z_OK){
105c3b: 0f b6 c0 movzbl %al,%eax
}
105c3e: 5e pop %esi
105c3f: 5f pop %edi
105c40: 5d pop %ebp
105c41: c3 ret
105c42: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105c49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
memset(&ctx->strm, 0, sizeof(ctx->strm));
105c50: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
105c55: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
105c58: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
105c5b: e9 75 ff ff ff jmp 105bd5 <Untar_GzChunkContext_Init+0x45> <== NOT EXECUTED
105c60: c6 83 f0 02 00 00 00 movb $0x0,0x2f0(%ebx) <== NOT EXECUTED
105c67: 8d 83 f1 02 00 00 lea 0x2f1(%ebx),%eax <== NOT EXECUTED
105c6d: b9 37 00 00 00 mov $0x37,%ecx <== NOT EXECUTED
105c72: e9 5a ff ff ff jmp 105bd1 <Untar_GzChunkContext_Init+0x41> <== NOT EXECUTED
105c77: 90 nop
105c78: 90 nop
105c79: 90 nop
105c7a: 90 nop
105c7b: 90 nop
105c7c: 90 nop
105c7d: 90 nop
105c7e: 90 nop
105c7f: 90 nop
00106c20 <Untar_ProcessHeader.part.0>:
return 0;
}
int
Untar_ProcessHeader(
106c20: 55 push %ebp
106c21: 89 e5 mov %esp,%ebp
106c23: 57 push %edi
106c24: 56 push %esi
num = 0;
106c25: 31 f6 xor %esi,%esi
Untar_ProcessHeader(
106c27: 53 push %ebx
106c28: 89 d3 mov %edx,%ebx
106c2a: 8d ba 9c 00 00 00 lea 0x9c(%edx),%edi
106c30: 81 ec 9c 00 00 00 sub $0x9c,%esp
106c36: 89 45 84 mov %eax,-0x7c(%ebp)
106c39: 8d 82 94 00 00 00 lea 0x94(%edx),%eax
106c3f: 90 nop
if ((octascii[i] < '0') || (octascii[i] > '9')) {
106c40: 0f be 10 movsbl (%eax),%edx
106c43: 88 d1 mov %dl,%cl
106c45: 80 e9 30 sub $0x30,%cl
106c48: 80 f9 09 cmp $0x9,%cl
106c4b: 77 04 ja 106c51 <Untar_ProcessHeader.part.0+0x31>
num = num * 8 + ((unsigned long)(octascii[i] - '0'));
106c4d: 8d 74 f2 d0 lea -0x30(%edx,%esi,8),%esi
for (i=0; i < len; i++) {
106c51: 40 inc %eax
106c52: 39 f8 cmp %edi,%eax
106c54: 75 ea jne 106c40 <Untar_ProcessHeader.part.0+0x20>
const char *bufr
)
{
int i, sum;
sum = 0;
106c56: 31 c9 xor %ecx,%ecx
for (i=0; i<512; i++) {
106c58: 31 c0 xor %eax,%eax
106c5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
106c60: 8d 50 01 lea 0x1(%eax),%edx
if ((i >= 148) && (i < 156))
106c63: 2d 94 00 00 00 sub $0x94,%eax
106c68: 83 f8 07 cmp $0x7,%eax
106c6b: 0f 86 0c 04 00 00 jbe 10707d <Untar_ProcessHeader.part.0+0x45d> <== NEVER TAKEN
sum += 0xff & ' ';
else
sum += 0xff & bufr[i];
106c71: 0f b6 44 13 ff movzbl -0x1(%ebx,%edx,1),%eax
106c76: 01 c1 add %eax,%ecx
for (i=0; i<512; i++) {
106c78: 81 fa 00 02 00 00 cmp $0x200,%edx
106c7e: 74 04 je 106c84 <Untar_ProcessHeader.part.0+0x64>
106c80: 89 d0 mov %edx,%eax
106c82: eb dc jmp 106c60 <Untar_ProcessHeader.part.0+0x40>
if (sum != hdr_chksum) {
106c84: 39 ce cmp %ecx,%esi
106c86: 0f 85 90 02 00 00 jne 106f1c <Untar_ProcessHeader.part.0+0x2fc> <== NEVER TAKEN
strlcpy(ctx->file_name, bufr, UNTAR_FILE_NAME_SIZE);
106c8c: 8b 75 84 mov -0x7c(%ebp),%esi
106c8f: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
106c95: b8 64 00 00 00 mov $0x64,%eax
106c9a: 89 44 24 08 mov %eax,0x8(%esp)
106c9e: 89 5c 24 04 mov %ebx,0x4(%esp)
106ca2: 8b 46 04 mov 0x4(%esi),%eax
106ca5: 89 04 24 mov %eax,(%esp)
106ca8: e8 33 60 02 00 call 12cce0 <strlcpy>
ctx->mode = strtoul(&bufr[100], NULL, 8);
106cad: b8 08 00 00 00 mov $0x8,%eax
106cb2: 89 44 24 08 mov %eax,0x8(%esp)
106cb6: 31 c0 xor %eax,%eax
106cb8: 89 44 24 04 mov %eax,0x4(%esp)
106cbc: 8d 43 64 lea 0x64(%ebx),%eax
106cbf: 89 04 24 mov %eax,(%esp)
106cc2: e8 09 6f 02 00 call 12dbd0 <strtoul>
106cc7: 89 46 6c mov %eax,0x6c(%esi)
ctx->linkflag = bufr[156];
106cca: 0f b6 83 9c 00 00 00 movzbl 0x9c(%ebx),%eax
106cd1: 88 46 78 mov %al,0x78(%esi)
num = 0;
106cd4: 31 f6 xor %esi,%esi
ctx->linkflag = bufr[156];
106cd6: 88 45 83 mov %al,-0x7d(%ebp)
106cd9: 8d 43 7c lea 0x7c(%ebx),%eax
106cdc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if ((octascii[i] < '0') || (octascii[i] > '9')) {
106ce0: 0f be 10 movsbl (%eax),%edx
106ce3: 88 d1 mov %dl,%cl
106ce5: 80 e9 30 sub $0x30,%cl
106ce8: 80 f9 09 cmp $0x9,%cl
106ceb: 77 04 ja 106cf1 <Untar_ProcessHeader.part.0+0xd1>
num = num * 8 + ((unsigned long)(octascii[i] - '0'));
106ced: 8d 74 f2 d0 lea -0x30(%edx,%esi,8),%esi
for (i=0; i < len; i++) {
106cf1: 40 inc %eax
106cf2: 39 c7 cmp %eax,%edi
106cf4: 75 ea jne 106ce0 <Untar_ProcessHeader.part.0+0xc0>
ctx->file_size = _rtems_octal2ulong(&bufr[124], 12);
106cf6: 8b 45 84 mov -0x7c(%ebp),%eax
106cf9: 89 70 70 mov %esi,0x70(%eax)
if (Make_Path(ctx->printer, ctx->file_path) != 0) {
106cfc: 8b 30 mov (%eax),%esi
106cfe: 8b 40 7c mov 0x7c(%eax),%eax
106d01: 89 85 7c ff ff ff mov %eax,-0x84(%ebp)
while (*path == '/') {
106d07: 0f b6 06 movzbl (%esi),%eax
106d0a: 3c 2f cmp $0x2f,%al
106d0c: 75 0b jne 106d19 <Untar_ProcessHeader.part.0+0xf9> <== ALWAYS TAKEN
106d0e: 66 90 xchg %ax,%ax
106d10: 0f b6 46 01 movzbl 0x1(%esi),%eax <== NOT EXECUTED
++path;
106d14: 46 inc %esi <== NOT EXECUTED
while (*path == '/') {
106d15: 3c 2f cmp $0x2f,%al <== NOT EXECUTED
106d17: 74 f7 je 106d10 <Untar_ProcessHeader.part.0+0xf0> <== NOT EXECUTED
if (p[0] == '\0') {
106d19: 84 c0 test %al,%al
106d1b: 0f 84 55 03 00 00 je 107076 <Untar_ProcessHeader.part.0+0x456> <== NEVER TAKEN
106d21: 89 f7 mov %esi,%edi
106d23: eb 37 jmp 106d5c <Untar_ProcessHeader.part.0+0x13c>
106d25: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106d2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*p = '\0';
106d30: c6 07 00 movb $0x0,(%edi)
if (p[1] == '\0') {
106d33: 84 d2 test %dl,%dl
106d35: 0f 84 0a 02 00 00 je 106f45 <Untar_ProcessHeader.part.0+0x325> <== NEVER TAKEN
if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) != 0) {
106d3b: 89 34 24 mov %esi,(%esp)
106d3e: b8 ff 01 00 00 mov $0x1ff,%eax
106d43: 89 44 24 04 mov %eax,0x4(%esp)
106d47: e8 e4 a6 ff ff call 101430 <mkdir>
106d4c: 85 c0 test %eax,%eax
106d4e: 75 60 jne 106db0 <Untar_ProcessHeader.part.0+0x190>
*p = '/';
106d50: c6 07 2f movb $0x2f,(%edi)
if (p[0] == '\0') {
106d53: 0f b6 47 01 movzbl 0x1(%edi),%eax
for (; ; ++p) {
106d57: 47 inc %edi
if (p[0] == '\0') {
106d58: 84 c0 test %al,%al
106d5a: 74 0f je 106d6b <Untar_ProcessHeader.part.0+0x14b> <== NEVER TAKEN
} else if (p[0] != '/') {
106d5c: 3c 2f cmp $0x2f,%al
if (p[1] == '\0') {
106d5e: 0f b6 57 01 movzbl 0x1(%edi),%edx
} else if (p[0] != '/') {
106d62: 74 cc je 106d30 <Untar_ProcessHeader.part.0+0x110>
if (p[1] == '\0') {
106d64: 88 d0 mov %dl,%al
for (; ; ++p) {
106d66: 47 inc %edi
if (p[0] == '\0') {
106d67: 84 c0 test %al,%al
106d69: 75 f1 jne 106d5c <Untar_ProcessHeader.part.0+0x13c>
if (ctx->linkflag == SYMTYPE) {
106d6b: 8b 45 84 mov -0x7c(%ebp),%eax
int retval = UNTAR_SUCCESSFUL;
106d6e: 31 f6 xor %esi,%esi
if (ctx->linkflag == SYMTYPE) {
106d70: 0f b6 40 78 movzbl 0x78(%eax),%eax
106d74: 88 45 83 mov %al,-0x7d(%ebp)
106d77: 80 7d 83 32 cmpb $0x32,-0x7d(%ebp)
106d7b: 0f 84 f3 00 00 00 je 106e74 <Untar_ProcessHeader.part.0+0x254>
} else if (ctx->linkflag == REGTYPE) {
106d81: 80 7d 83 30 cmpb $0x30,-0x7d(%ebp)
106d85: 0f 84 d3 01 00 00 je 106f5e <Untar_ProcessHeader.part.0+0x33e> <== ALWAYS TAKEN
} else if (ctx->linkflag == DIRTYPE) {
106d8b: 80 7d 83 35 cmpb $0x35,-0x7d(%ebp) <== NOT EXECUTED
106d8f: 0f 84 12 02 00 00 je 106fa7 <Untar_ProcessHeader.part.0+0x387> <== NOT EXECUTED
}
106d95: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
106d9b: 89 f0 mov %esi,%eax <== NOT EXECUTED
106d9d: 5b pop %ebx <== NOT EXECUTED
106d9e: 5e pop %esi <== NOT EXECUTED
106d9f: 5f pop %edi <== NOT EXECUTED
106da0: 5d pop %ebp <== NOT EXECUTED
106da1: c3 ret <== NOT EXECUTED
106da2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106da9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (errno == EEXIST || errno == EISDIR) {
106db0: e8 eb 35 02 00 call 12a3a0 <__errno>
106db5: 83 38 11 cmpl $0x11,(%eax)
106db8: 74 0a je 106dc4 <Untar_ProcessHeader.part.0+0x1a4> <== ALWAYS TAKEN
106dba: e8 e1 35 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
106dbf: 83 38 15 cmpl $0x15,(%eax) <== NOT EXECUTED
106dc2: 75 8c jne 106d50 <Untar_ProcessHeader.part.0+0x130> <== NOT EXECUTED
if (stat(path, &sb) != 0) {
106dc4: 89 34 24 mov %esi,(%esp)
106dc7: 8d 45 90 lea -0x70(%ebp),%eax
106dca: 89 44 24 04 mov %eax,0x4(%esp)
106dce: e8 dd b5 ff ff call 1023b0 <stat>
106dd3: 85 c0 test %eax,%eax
106dd5: 0f 85 80 00 00 00 jne 106e5b <Untar_ProcessHeader.part.0+0x23b> <== NEVER TAKEN
if (!S_ISDIR(sb.st_mode)) {
106ddb: 8b 45 a0 mov -0x60(%ebp),%eax
106dde: 25 00 f0 00 00 and $0xf000,%eax
106de3: 3d 00 40 00 00 cmp $0x4000,%eax
106de8: 0f 84 62 ff ff ff je 106d50 <Untar_ProcessHeader.part.0+0x130> <== ALWAYS TAKEN
if (unlink(path) != 0) {
106dee: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
106df1: e8 3a d2 ff ff call 104030 <unlink> <== NOT EXECUTED
106df6: 85 c0 test %eax,%eax <== NOT EXECUTED
106df8: 0f 85 2f 02 00 00 jne 10702d <Untar_ProcessHeader.part.0+0x40d> <== NOT EXECUTED
if (mkdir(path, S_IRWXU | S_IRWXG | S_IRWXO) != 0) {
106dfe: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
106e01: ba ff 01 00 00 mov $0x1ff,%edx <== NOT EXECUTED
106e06: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
106e0a: e8 21 a6 ff ff call 101430 <mkdir> <== NOT EXECUTED
106e0f: 85 c0 test %eax,%eax <== NOT EXECUTED
106e11: 0f 84 39 ff ff ff je 106d50 <Untar_ProcessHeader.part.0+0x130> <== NOT EXECUTED
message, path, errno, strerror(errno));
106e17: e8 84 35 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106e1c: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106e1e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106e21: e8 9a 5e 02 00 call 12ccc0 <strerror> <== NOT EXECUTED
106e26: 89 c7 mov %eax,%edi <== NOT EXECUTED
message, path, errno, strerror(errno));
106e28: e8 73 35 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106e2d: 89 7c 24 14 mov %edi,0x14(%esp) <== NOT EXECUTED
106e31: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106e33: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
106e37: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
106e3b: b8 b4 9a 13 00 mov $0x139ab4,%eax <== NOT EXECUTED
106e40: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106e44: b8 9c 9a 13 00 mov $0x139a9c,%eax <== NOT EXECUTED
106e49: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106e4d: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED
106e53: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106e56: e8 45 b2 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
106e5b: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
retval = UNTAR_FAIL;
106e5e: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
106e63: 0f b6 40 78 movzbl 0x78(%eax),%eax <== NOT EXECUTED
106e67: 88 45 83 mov %al,-0x7d(%ebp) <== NOT EXECUTED
106e6a: 80 7d 83 32 cmpb $0x32,-0x7d(%ebp) <== NOT EXECUTED
106e6e: 0f 85 0d ff ff ff jne 106d81 <Untar_ProcessHeader.part.0+0x161> <== NOT EXECUTED
strlcpy(ctx->link_name, &bufr[157], sizeof(ctx->link_name));
106e74: 8b 45 84 mov -0x7c(%ebp),%eax
106e77: 81 c3 9d 00 00 00 add $0x9d,%ebx
106e7d: 89 5c 24 04 mov %ebx,0x4(%esp)
106e81: 8d 78 08 lea 0x8(%eax),%edi
106e84: b8 64 00 00 00 mov $0x64,%eax
106e89: 89 44 24 08 mov %eax,0x8(%esp)
106e8d: 89 3c 24 mov %edi,(%esp)
106e90: e8 4b 5e 02 00 call 12cce0 <strlcpy>
rtems_printf(ctx->printer, "untar: symlink: %s -> %s\n",
106e95: 8b 5d 84 mov -0x7c(%ebp),%ebx
106e98: 8b 03 mov (%ebx),%eax
106e9a: 89 7c 24 08 mov %edi,0x8(%esp)
106e9e: 89 44 24 0c mov %eax,0xc(%esp)
106ea2: b8 c3 9a 13 00 mov $0x139ac3,%eax
106ea7: 89 44 24 04 mov %eax,0x4(%esp)
106eab: 8b 43 7c mov 0x7c(%ebx),%eax
106eae: 89 04 24 mov %eax,(%esp)
106eb1: e8 ea b1 ff ff call 1020a0 <rtems_printf>
r = symlink(ctx->link_name, ctx->file_path);
106eb6: 8b 03 mov (%ebx),%eax
106eb8: 89 3c 24 mov %edi,(%esp)
106ebb: 89 44 24 04 mov %eax,0x4(%esp)
106ebf: e8 8c c8 ff ff call 103750 <symlink>
if (r != 0) {
106ec4: 85 c0 test %eax,%eax
106ec6: 0f 84 c9 fe ff ff je 106d95 <Untar_ProcessHeader.part.0+0x175> <== ALWAYS TAKEN
Print_Error(ctx->printer, "symlink", ctx->file_path);
106ecc: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
106ecf: 8b 38 mov (%eax),%edi <== NOT EXECUTED
106ed1: 8b 70 7c mov 0x7c(%eax),%esi <== NOT EXECUTED
message, path, errno, strerror(errno));
106ed4: e8 c7 34 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106ed9: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106edb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106ede: e8 dd 5d 02 00 call 12ccc0 <strerror> <== NOT EXECUTED
106ee3: 89 c3 mov %eax,%ebx <== NOT EXECUTED
message, path, errno, strerror(errno));
106ee5: e8 b6 34 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106eea: 89 5c 24 14 mov %ebx,0x14(%esp) <== NOT EXECUTED
106eee: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106ef0: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
106ef4: bf dd 9a 13 00 mov $0x139add,%edi <== NOT EXECUTED
106ef9: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
retval = UNTAR_FAIL;
106efc: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106f01: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
106f05: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
106f09: b8 9c 9a 13 00 mov $0x139a9c,%eax <== NOT EXECUTED
106f0e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106f12: e8 89 b1 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
}
106f17: e9 79 fe ff ff jmp 106d95 <Untar_ProcessHeader.part.0+0x175> <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file header checksum error\n");
106f1c: b8 50 9a 13 00 mov $0x139a50,%eax <== NOT EXECUTED
return UNTAR_INVALID_CHECKSUM;
106f21: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file header checksum error\n");
106f26: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106f2a: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
106f2d: 8b 40 7c mov 0x7c(%eax),%eax <== NOT EXECUTED
106f30: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106f33: e8 68 b1 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
}
106f38: 81 c4 9c 00 00 00 add $0x9c,%esp <== NOT EXECUTED
106f3e: 89 f0 mov %esi,%eax <== NOT EXECUTED
106f40: 5b pop %ebx <== NOT EXECUTED
106f41: 5e pop %esi <== NOT EXECUTED
106f42: 5f pop %edi <== NOT EXECUTED
106f43: 5d pop %ebp <== NOT EXECUTED
106f44: c3 ret <== NOT EXECUTED
unlink(path);
106f45: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
int retval = UNTAR_SUCCESSFUL;
106f48: 31 f6 xor %esi,%esi <== NOT EXECUTED
unlink(path);
106f4a: e8 e1 d0 ff ff call 104030 <unlink> <== NOT EXECUTED
if (ctx->linkflag == SYMTYPE) {
106f4f: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
106f52: 0f b6 40 78 movzbl 0x78(%eax),%eax <== NOT EXECUTED
106f56: 88 45 83 mov %al,-0x7d(%ebp) <== NOT EXECUTED
106f59: e9 19 fe ff ff jmp 106d77 <Untar_ProcessHeader.part.0+0x157> <== NOT EXECUTED
rtems_printf(ctx->printer, "untar: file: %s (s:%lu,m:%04lo)\n",
106f5e: 8b 7d 84 mov -0x7c(%ebp),%edi
106f61: bb 74 9a 13 00 mov $0x139a74,%ebx
106f66: 8b 47 6c mov 0x6c(%edi),%eax
106f69: 89 44 24 10 mov %eax,0x10(%esp)
106f6d: 8b 47 70 mov 0x70(%edi),%eax
106f70: 89 44 24 0c mov %eax,0xc(%esp)
106f74: 8b 07 mov (%edi),%eax
106f76: 89 5c 24 04 mov %ebx,0x4(%esp)
106f7a: 89 44 24 08 mov %eax,0x8(%esp)
106f7e: 8b 47 7c mov 0x7c(%edi),%eax
106f81: 89 04 24 mov %eax,(%esp)
106f84: e8 17 b1 ff ff call 1020a0 <rtems_printf>
ctx->nblocks = (((ctx->file_size) + 511) & ~511) / 512;
106f89: 8b 47 70 mov 0x70(%edi),%eax
106f8c: 89 45 84 mov %eax,-0x7c(%ebp)
106f8f: 05 ff 01 00 00 add $0x1ff,%eax
106f94: c1 e8 09 shr $0x9,%eax
106f97: 89 47 74 mov %eax,0x74(%edi)
}
106f9a: 81 c4 9c 00 00 00 add $0x9c,%esp
106fa0: 89 f0 mov %esi,%eax
106fa2: 5b pop %ebx
106fa3: 5e pop %esi
106fa4: 5f pop %edi
106fa5: 5d pop %ebp
106fa6: c3 ret
rtems_printf(ctx->printer, "untar: dir: %s\n", ctx->file_path);
106fa7: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED
106faa: b9 e5 9a 13 00 mov $0x139ae5,%ecx <== NOT EXECUTED
106faf: 8b 07 mov (%edi),%eax <== NOT EXECUTED
106fb1: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
106fb5: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106fb9: 8b 47 7c mov 0x7c(%edi),%eax <== NOT EXECUTED
106fbc: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106fbf: e8 dc b0 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
r = mkdir(ctx->file_path, ctx->mode);
106fc4: 8b 47 6c mov 0x6c(%edi),%eax <== NOT EXECUTED
106fc7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106fcb: 8b 07 mov (%edi),%eax <== NOT EXECUTED
106fcd: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106fd0: e8 5b a4 ff ff call 101430 <mkdir> <== NOT EXECUTED
if (r != 0) {
106fd5: 85 c0 test %eax,%eax <== NOT EXECUTED
106fd7: 0f 84 b8 fd ff ff je 106d95 <Untar_ProcessHeader.part.0+0x175> <== NOT EXECUTED
Print_Error(ctx->printer, "mkdir", ctx->file_path);
106fdd: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED
106fe0: 8b 70 7c mov 0x7c(%eax),%esi <== NOT EXECUTED
106fe3: 8b 38 mov (%eax),%edi <== NOT EXECUTED
message, path, errno, strerror(errno));
106fe5: e8 b6 33 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106fea: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106fec: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
106fef: e8 cc 5c 02 00 call 12ccc0 <strerror> <== NOT EXECUTED
106ff4: 89 c3 mov %eax,%ebx <== NOT EXECUTED
message, path, errno, strerror(errno));
106ff6: e8 a5 33 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
106ffb: ba 9c 9a 13 00 mov $0x139a9c,%edx <== NOT EXECUTED
107000: 89 5c 24 14 mov %ebx,0x14(%esp) <== NOT EXECUTED
107004: 8b 00 mov (%eax),%eax <== NOT EXECUTED
107006: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
retval = UNTAR_FAIL;
107009: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
10700e: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
107012: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
107016: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10701a: b8 f5 9a 13 00 mov $0x139af5,%eax <== NOT EXECUTED
10701f: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
107023: e8 78 b0 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
}
107028: e9 68 fd ff ff jmp 106d95 <Untar_ProcessHeader.part.0+0x175> <== NOT EXECUTED
message, path, errno, strerror(errno));
10702d: e8 6e 33 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
107032: 8b 00 mov (%eax),%eax <== NOT EXECUTED
107034: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
107037: e8 84 5c 02 00 call 12ccc0 <strerror> <== NOT EXECUTED
10703c: 89 c7 mov %eax,%edi <== NOT EXECUTED
message, path, errno, strerror(errno));
10703e: e8 5d 33 02 00 call 12a3a0 <__errno> <== NOT EXECUTED
rtems_printf(printer, "untar: %s: %s: (%d) %s\n",
107043: b9 95 9a 13 00 mov $0x139a95,%ecx <== NOT EXECUTED
107048: 89 7c 24 14 mov %edi,0x14(%esp) <== NOT EXECUTED
10704c: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10704e: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
107052: be 9c 9a 13 00 mov $0x139a9c,%esi <== NOT EXECUTED
107057: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10705b: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10705f: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
107063: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED
107069: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10706c: e8 2f b0 ff ff call 1020a0 <rtems_printf> <== NOT EXECUTED
}
107071: e9 e5 fd ff ff jmp 106e5b <Untar_ProcessHeader.part.0+0x23b> <== NOT EXECUTED
int retval = UNTAR_SUCCESSFUL;
107076: 31 f6 xor %esi,%esi <== NOT EXECUTED
107078: e9 fa fc ff ff jmp 106d77 <Untar_ProcessHeader.part.0+0x157> <== NOT EXECUTED
sum += 0xff & ' ';
10707d: 83 c1 20 add $0x20,%ecx
for (i=0; i<512; i++) {
107080: 89 d0 mov %edx,%eax
107082: e9 d9 fb ff ff jmp 106c60 <Untar_ProcessHeader.part.0+0x40>
107087: 90 nop
107088: 90 nop
107089: 90 nop
10708a: 90 nop
10708b: 90 nop
10708c: 90 nop
10708d: 90 nop
10708e: 90 nop
10708f: 90 nop