valentineus/0xFFFF
1
Fork 0
Code Releases Activity

Added new global macros for ERROR/WARNING/VERBOSE, use it

Browse Source
This commit is contained in:
Pali Rohár committed 2012-08-09 17:50:50 +02:00
1 parent 01239ea839
commit 5310efb16c
5 files changed
+142 -157
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/fiasco2.c
+94 -114
View File
@@ -28,23 +28,22 @@
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include "global.h"
#include "device.h" #include "device.h"
#include "image.h" #include "image.h"
#include "fiasco2.h" #include "fiasco2.h"
#define FIASCO_READ_ERROR(fiasco, error) do { fprintf(stderr, "Error: %s\n", error); fiasco_free(fiasco); return NULL; } while (0) #define FIASCO_READ_ERROR(fiasco, format, ...) do { ERROR(errno, format, ##__VA_ARGS__); fiasco_free(fiasco); return NULL; } while (0)
#define FIASCO_WRITE_ERROR(file, fd, error) do { fprintf(stderr, "Error: %s: %s\n", file, error); if ( fd >= 0 ) close(fd); return -1; } while (0) #define FIASCO_WRITE_ERROR(file, fd, format, ...) do { ERROR(errno, "%s: " format, file, ##__VA_ARGS__); if ( fd >= 0 ) close(fd); return -1; } while (0)
#define READ_OR_FAIL(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) { fprintf(stderr, "Error: Cannot read %d bytes\n", size); fiasco_free(fiasco); return NULL; } } while (0) #define READ_OR_FAIL(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) { FIASCO_READ_ERROR(fiasco, "Cannot read %d bytes", size); } } while (0)
#define READ_OR_RETURN(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) return fiasco; } while (0) #define READ_OR_RETURN(fiasco, buf, size) do { if ( read(fiasco->fd, buf, size) != size ) return fiasco; } while (0)
#define WRITE_OR_FAIL(fd, buf, size) do { if ( write(fd, buf, size) != size ) { fprintf(stderr, "Error: Cannot write %d bytes\n", size); close(fd); return -1; } } while (0) #define WRITE_OR_FAIL(file, fd, buf, size) do { if ( ! simulate ) { if ( write(fd, buf, size) != size ) { FIASCO_WRITE_ERROR(file, fd, "Cannot write %d bytes", size); } } } while (0)
struct fiasco * fiasco_alloc_empty(void) { struct fiasco * fiasco_alloc_empty(void) {
struct fiasco * fiasco = calloc(1, sizeof(struct fiasco)); struct fiasco * fiasco = calloc(1, sizeof(struct fiasco));
if ( ! fiasco ) { if ( ! fiasco )
perror("Cannot allocate memory"); ALLOC_ERROR_RETURN(NULL);
return NULL;
}
fiasco->fd = -1; fiasco->fd = -1;
return fiasco; return fiasco;
@@ -72,15 +71,13 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
unsigned char buf[512]; unsigned char buf[512];
unsigned char *pbuf; unsigned char *pbuf;
int v = 1;
struct fiasco * fiasco = fiasco_alloc_empty(); struct fiasco * fiasco = fiasco_alloc_empty();
if ( ! fiasco ) if ( ! fiasco )
return NULL; return NULL;
fiasco->fd = open(file, O_RDONLY); fiasco->fd = open(file, O_RDONLY);
if ( fiasco->fd < 0 ) { if ( fiasco->fd < 0 ) {
perror("Cannot open file"); ERROR(errno, "Cannot open file");
fiasco_free(fiasco); fiasco_free(fiasco);
return NULL; return NULL;
} }
@@ -97,7 +94,7 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
READ_OR_FAIL(fiasco, &count, 4); READ_OR_FAIL(fiasco, &count, 4);
count = ntohl(count); count = ntohl(count);
if ( v ) printf("Number of header blocks: %d\n", count); VERBOSE("Number of header blocks: %d\n", count);
while ( count > 0 ) { while ( count > 0 ) {
READ_OR_FAIL(fiasco, &byte, 1); READ_OR_FAIL(fiasco, &byte, 1);
@@ -106,13 +103,13 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
if ( byte == 0xe8 ) { if ( byte == 0xe8 ) {
memset(fiasco->name, 0, sizeof(fiasco->name)); memset(fiasco->name, 0, sizeof(fiasco->name));
strncpy(fiasco->name, (char *)buf, length8); strncpy(fiasco->name, (char *)buf, length8);
if ( v ) printf("Fiasco name: %s\n", fiasco->name); VERBOSE("Fiasco name: %s\n", fiasco->name);
} else if ( byte == 0x31 ) { } else if ( byte == 0x31 ) {
memset(fiasco->swver, 0, sizeof(fiasco->swver)); memset(fiasco->swver, 0, sizeof(fiasco->swver));
strncpy(fiasco->swver, (char *)buf, length8); strncpy(fiasco->swver, (char *)buf, length8);
if ( v ) printf("SW version: %s\n", fiasco->swver); VERBOSE("SW version: %s\n", fiasco->swver);
} else { } else {
if ( v ) printf("Unknown header %#x\n", byte); VERBOSE("Unknown header %#x\n", byte);
} }
--count; --count;
} }
@@ -125,7 +122,7 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
/* Header of next image */ /* Header of next image */
if ( ! buf[0] == 0x54 && buf[2] == 0x2E && buf[3] == 0x19 && buf[4] == 0x01 && buf[5] == 0x01 && buf[6] == 0x00 ) { if ( ! buf[0] == 0x54 && buf[2] == 0x2E && buf[3] == 0x19 && buf[4] == 0x01 && buf[5] == 0x01 && buf[6] == 0x00 ) {
printf("Invalid next image header\n"); ERROR(0, "Invalid next image header");
return fiasco; return fiasco;
} }
@@ -139,12 +136,11 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
memset(type, 0, sizeof(type)); memset(type, 0, sizeof(type));
READ_OR_RETURN(fiasco, type, 12); READ_OR_RETURN(fiasco, type, 12);
// memcpy(byte, type, 1);
byte = type[0]; byte = type[0];
if ( byte == 0xFF ) if ( byte == 0xFF )
return fiasco; return fiasco;
if ( v ) printf(" %s\n", type); VERBOSE(" %s\n", type);
READ_OR_RETURN(fiasco, &length, 4); READ_OR_RETURN(fiasco, &length, 4);
length = ntohl(length); length = ntohl(length);
@@ -152,11 +148,9 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
/* unknown */ /* unknown */
READ_OR_RETURN(fiasco, buf, 4); READ_OR_RETURN(fiasco, buf, 4);
if ( v ) { VERBOSE(" size: %d bytes\n", length);
printf(" size: %d bytes\n", length); VERBOSE(" hash: %#04x\n", hash);
printf(" hash: %#04x\n", hash); VERBOSE(" subsections: %d\n", count8);
printf(" subsections: %d\n", count8);
}
memset(device, 0, sizeof(device)); memset(device, 0, sizeof(device));
memset(hwrevs, 0, sizeof(hwrevs)); memset(hwrevs, 0, sizeof(hwrevs));
@@ -169,26 +163,22 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
READ_OR_RETURN(fiasco, &length8, 1); READ_OR_RETURN(fiasco, &length8, 1);
READ_OR_RETURN(fiasco, buf, length8); READ_OR_RETURN(fiasco, buf, length8);
if ( v ) { VERBOSE(" subinfo\n");
printf(" subinfo\n"); VERBOSE(" length: %d\n", length8);
printf(" length: %d\n", length8); VERBOSE(" type: ");
printf(" type: ");
}
if ( byte == '1' ) { if ( byte == '1' ) {
memset(version, 0, sizeof(version)); memset(version, 0, sizeof(version));
strncpy(version, (char *)buf, length8); strncpy(version, (char *)buf, length8);
if ( v ) { VERBOSE("version string\n");
printf("version string\n"); VERBOSE(" version: %s\n", version);
printf(" version: %s\n", version);
}
} else if ( byte == '2' ) { } else if ( byte == '2' ) {
int tmp = length8; int tmp = length8;
if ( tmp > 16 ) tmp = 16; if ( tmp > 16 ) tmp = 16;
memset(device, 0, sizeof(device)); memset(device, 0, sizeof(device));
strncpy(device, (char *)buf, tmp); strncpy(device, (char *)buf, tmp);
if ( v ) printf("hw revision\n"); VERBOSE("hw revision\n");
printf(" device: %s\n", device); VERBOSE(" device: %s\n", device);
pbuf = buf + strlen(device) + 1; pbuf = buf + strlen(device) + 1;
while ( pbuf < buf + length8 ) { while ( pbuf < buf + length8 ) {
while ( pbuf < buf + length8 && *pbuf < 32 ) while ( pbuf < buf + length8 && *pbuf < 32 )
@@ -205,15 +195,15 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
strcat(hwrevs, ","); strcat(hwrevs, ",");
strcat(hwrevs, hwrev); strcat(hwrevs, hwrev);
} }
if ( v ) printf(" hw revision: %s\n", hwrev); VERBOSE(" hw revision: %s\n", hwrev);
pbuf += strlen(hwrev) + 1; pbuf += strlen(hwrev) + 1;
} }
} else if ( byte == '3' ) { } else if ( byte == '3' ) {
memset(layout, 0, sizeof(layout)); memset(layout, 0, sizeof(layout));
strncpy(layout, (char *)buf, length8); strncpy(layout, (char *)buf, length8);
if ( v ) printf("layout\n"); VERBOSE("layout\n");
} else { } else {
if ( v ) printf("unknown ('%c':%#x)\n", byte, byte); VERBOSE("unknown ('%c':%#x)\n", byte, byte);
} }
--count8; --count8;
@@ -224,12 +214,10 @@ struct fiasco * fiasco_alloc_from_file(const char * file) {
offset = lseek(fiasco->fd, 0, SEEK_CUR); offset = lseek(fiasco->fd, 0, SEEK_CUR);
if ( v ) { VERBOSE(" version: %s\n", version);
printf(" version: %s\n", version); VERBOSE(" device: %s\n", device);
printf(" device: %s\n", device); VERBOSE(" hwrevs: %s\n", hwrevs);
printf(" hwrevs: %s\n", hwrevs); VERBOSE(" data at: %#08x\n", (unsigned int)offset);
printf(" data at: %#08x\n", (unsigned int)offset);
}
image = image_alloc_from_shared_fd(fiasco->fd, length, offset, hash, type, device, hwrevs, version, layout); image = image_alloc_from_shared_fd(fiasco->fd, length, offset, hash, type, device, hwrevs, version, layout);
@@ -288,6 +276,8 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
if ( ! fiasco ) if ( ! fiasco )
return -1; return -1;
printf("Generating Fiasco image %s...\n", file);
if ( ! fiasco->first ) if ( ! fiasco->first )
FIASCO_WRITE_ERROR(file, fd, "Nothing to write"); FIASCO_WRITE_ERROR(file, fd, "Nothing to write");
@@ -297,17 +287,17 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
if ( fiasco->swver && strlen(fiasco->swver)+1 > UINT8_MAX ) if ( fiasco->swver && strlen(fiasco->swver)+1 > UINT8_MAX )
FIASCO_WRITE_ERROR(file, fd, "SW version string is too long"); FIASCO_WRITE_ERROR(file, fd, "SW version string is too long");
if ( ! simulate ) {
fd = open(file, O_RDWR|O_CREAT|O_TRUNC, 0644); fd = open(file, O_RDWR|O_CREAT|O_TRUNC, 0644);
if ( fd < 0 ) { if ( fd < 0 ) {
perror("Cannot create file"); ERROR(errno, "Cannot create file");
return -1; return -1;
} }
}
printf("Writing file header\n"); printf("Writing Fiasco header...\n");
WRITE_OR_FAIL(fd, "\xb4", 1); /* signature */ WRITE_OR_FAIL(file, fd, "\xb4", 1); /* signature */
printf("Writing FW header\n");
if ( fiasco->name[0] ) if ( fiasco->name[0] )
str = fiasco->name; str = fiasco->name;
@@ -318,29 +308,31 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
if ( fiasco->swver[0] ) if ( fiasco->swver[0] )
length += strlen(fiasco->swver) + 3; length += strlen(fiasco->swver) + 3;
length = htonl(length); length = htonl(length);
WRITE_OR_FAIL(fd, &length, 4); /* FW header length */ WRITE_OR_FAIL(file, fd, &length, 4); /* FW header length */
if ( fiasco->swver[0] ) if ( fiasco->swver[0] )
length = htonl(2); length = htonl(2);
else else
length = htonl(1); length = htonl(1);
WRITE_OR_FAIL(fd, &length, 4); /* FW header blocks count */ WRITE_OR_FAIL(file, fd, &length, 4); /* FW header blocks count */
/* Fiasco name */ /* Fiasco name */
length8 = strlen(str)+1; length8 = strlen(str)+1;
WRITE_OR_FAIL(fd, "\xe8", 1); WRITE_OR_FAIL(file, fd, "\xe8", 1);
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
WRITE_OR_FAIL(fd, str, length8); WRITE_OR_FAIL(file, fd, str, length8);
/* SW version */ /* SW version */
if ( fiasco->swver[0] ) { if ( fiasco->swver[0] ) {
printf("Writing SW version: %s\n", fiasco->swver); printf("Writing SW version: %s\n", fiasco->swver);
length8 = strlen(fiasco->swver)+1; length8 = strlen(fiasco->swver)+1;
WRITE_OR_FAIL(fd, "\x31", 1); WRITE_OR_FAIL(file, fd, "\x31", 1);
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
WRITE_OR_FAIL(fd, fiasco->swver, length8); WRITE_OR_FAIL(file, fd, fiasco->swver, length8);
}; };
printf("\n");
image_list = fiasco->first; image_list = fiasco->first;
while ( image_list ) { while ( image_list ) {
@@ -350,6 +342,9 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
if ( ! image ) if ( ! image )
FIASCO_WRITE_ERROR(file, fd, "Empty image"); FIASCO_WRITE_ERROR(file, fd, "Empty image");
printf("Writing image...\n");
image_print_info(image);
type = image_type_to_string(image->type); type = image_type_to_string(image->type);
device = device_to_string(image->device); device = device_to_string(image->device);
@@ -362,27 +357,10 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
if ( image->layout && strlen(image->layout) > UINT8_MAX ) if ( image->layout && strlen(image->layout) > UINT8_MAX )
FIASCO_WRITE_ERROR(file, fd, "Image layout is too long"); FIASCO_WRITE_ERROR(file, fd, "Image layout is too long");
printf("Writing image:\n"); printf("Writing image header...\n");
printf(" type: %s\n", type);
printf(" hash: %d\n", image->hash);
printf(" size: %d\n", image->size);
if ( device )
printf(" device: %s\n", device);
if ( image->hwrevs )
printf(" hwrevs: %s\n", image->hwrevs);
if ( image->version )
printf(" version: %s\n", image->version);
if ( image->layout )
printf(" layout: included\n");
printf("Writing image header\n");
/* signature */ /* signature */
WRITE_OR_FAIL(fd, "T", 1); WRITE_OR_FAIL(file, fd, "T", 1);
/* number of subsections */ /* number of subsections */
length8 = 1; length8 = 1;
@@ -392,33 +370,33 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
++length8; ++length8;
if ( image->layout ) if ( image->layout )
++length8; ++length8;
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
/* unknown */ /* unknown */
WRITE_OR_FAIL(fd, "\x2e\x19\x01\x01\x00", 5); WRITE_OR_FAIL(file, fd, "\x2e\x19\x01\x01\x00", 5);
/* checksum */ /* checksum */
hash = htons(image->hash); hash = htons(image->hash);
WRITE_OR_FAIL(fd, &hash, 2); WRITE_OR_FAIL(file, fd, &hash, 2);
/* image type name */ /* image type name */
memset(buf, 0, 12); memset(buf, 0, 12);
strncpy((char *)buf, type, 12); strncpy((char *)buf, type, 12);
WRITE_OR_FAIL(fd, buf, 12); WRITE_OR_FAIL(file, fd, buf, 12);
/* image size */ /* image size */
size = htonl(image->size); size = htonl(image->size);
WRITE_OR_FAIL(fd, &size, 4); WRITE_OR_FAIL(file, fd, &size, 4);
/* unknown */ /* unknown */
WRITE_OR_FAIL(fd, "\x00\x00\x00\x00", 4); WRITE_OR_FAIL(file, fd, "\x00\x00\x00\x00", 4);
/* append version subsection */ /* append version subsection */
if ( image->version ) { if ( image->version ) {
WRITE_OR_FAIL(fd, "1", 1); /* 1 - version */ WRITE_OR_FAIL(file, fd, "1", 1); /* 1 - version */
length8 = strlen(image->version)+1; length8 = strlen(image->version)+1;
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
WRITE_OR_FAIL(fd, image->version, length8); WRITE_OR_FAIL(file, fd, image->version, length8);
} }
/* append device & hwrevs subsection */ /* append device & hwrevs subsection */
@@ -426,7 +404,7 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
const char *ptr = image->hwrevs; const char *ptr = image->hwrevs;
const char *oldptr = ptr; const char *oldptr = ptr;
int i; int i;
WRITE_OR_FAIL(fd, "2", 1); /* 2 - device & hwrevs */ WRITE_OR_FAIL(file, fd, "2", 1); /* 2 - device & hwrevs */
length8 = 16; length8 = 16;
if ( image->hwrevs ) { if ( image->hwrevs ) {
i = 1; i = 1;
@@ -436,57 +414,62 @@ int fiasco_write_to_file(struct fiasco * fiasco, const char * file) {
} }
length8 += i*8; length8 += i*8;
} }
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
length8 = strlen(device); length8 = strlen(device);
if ( length8 > 15 ) length8 = 15; if ( length8 > 15 ) length8 = 15;
WRITE_OR_FAIL(fd, device, length8); WRITE_OR_FAIL(file, fd, device, length8);
for ( i = 0; i < 16 - length8; ++i ) for ( i = 0; i < 16 - length8; ++i )
WRITE_OR_FAIL(fd, "\x00", 1); WRITE_OR_FAIL(file, fd, "\x00", 1);
if ( image->hwrevs ) { if ( image->hwrevs ) {
ptr = image->hwrevs; ptr = image->hwrevs;
oldptr = ptr; oldptr = ptr;
while ( (ptr = strchr(ptr, ',')) ) { while ( (ptr = strchr(ptr, ',')) ) {
length8 = ptr-oldptr; length8 = ptr-oldptr;
if ( length8 > 8 ) length8 = 8; if ( length8 > 8 ) length8 = 8;
WRITE_OR_FAIL(fd, oldptr, length8); WRITE_OR_FAIL(file, fd, oldptr, length8);
for ( i=0; i < 8 - length8; ++i ) for ( i=0; i < 8 - length8; ++i )
WRITE_OR_FAIL(fd, "\x00", 1); WRITE_OR_FAIL(file, fd, "\x00", 1);
++ptr; ++ptr;
oldptr = ptr; oldptr = ptr;
} }
length8 = strlen(oldptr); length8 = strlen(oldptr);
if ( length8 > 8 ) length8 = 8; if ( length8 > 8 ) length8 = 8;
WRITE_OR_FAIL(fd, oldptr, length8); WRITE_OR_FAIL(file, fd, oldptr, length8);
for ( i = 0; i < 8 - length8; ++i ) for ( i = 0; i < 8 - length8; ++i )
WRITE_OR_FAIL(fd, "\x00", 1); WRITE_OR_FAIL(file, fd, "\x00", 1);
} }
} }
/* append layout subsection */ /* append layout subsection */
if ( image->layout ) { if ( image->layout ) {
length8 = strlen(image->layout); length8 = strlen(image->layout);
WRITE_OR_FAIL(fd, "3", 1); /* 3 - layout */ WRITE_OR_FAIL(file, fd, "3", 1); /* 3 - layout */
WRITE_OR_FAIL(fd, &length8, 1); WRITE_OR_FAIL(file, fd, &length8, 1);
WRITE_OR_FAIL(fd, image->layout, length8); WRITE_OR_FAIL(file, fd, image->layout, length8);
} }
/* dummy byte - end of all subsections */ /* dummy byte - end of all subsections */
WRITE_OR_FAIL(fd, "\x00", 1); WRITE_OR_FAIL(file, fd, "\x00", 1);
printf("Writing image data...\n");
image_seek(image, 0); image_seek(image, 0);
while ( 1 ) { while ( 1 ) {
size = image_read(image, buf, sizeof(buf)); size = image_read(image, buf, sizeof(buf));
if ( size < 1 ) if ( size < 1 )
break; break;
WRITE_OR_FAIL(fd, buf, size); WRITE_OR_FAIL(file, fd, buf, size);
} }
image_list = image_list->next; image_list = image_list->next;
if ( image_list )
printf("\n");
} }
printf("Done\n");
close(fd); close(fd);
printf("\nDone\n\n");
return 0; return 0;
} }
@@ -507,17 +490,19 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
memset(cwd, 0, sizeof(cwd)); memset(cwd, 0, sizeof(cwd));
if ( ! getcwd(cwd, sizeof(cwd)) ) { if ( ! getcwd(cwd, sizeof(cwd)) ) {
perror("Cannot getcwd"); ERROR(errno, "Cannot store current directory");
return -1; return -1;
} }
if ( chdir(dir) < 0 ) { if ( chdir(dir) < 0 ) {
perror("Cannot chdir"); ERROR(errno, "Cannot change current directory to %s", dir);
return -1; return -1;
} }
} }
fiasco_print_info(fiasco);
image_list = fiasco->first; image_list = fiasco->first;
while ( image_list ) { while ( image_list ) {
@@ -526,16 +511,15 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
name = image_name_alloc_from_values(image); name = image_name_alloc_from_values(image);
printf("\n");
printf("Unpacking image...\n"); printf("Unpacking image...\n");
image_print_info(image); image_print_info(image);
if ( image->layout ) { if ( image->layout ) {
layout_name = calloc(1, strlen(name) + strlen(".layout") + 1); layout_name = calloc(1, strlen(name) + strlen(".layout") + 1);
if ( ! layout_name ) { if ( ! layout_name )
perror("Alloc error"); ALLOC_ERROR_RETURN(-1);
return -1;
}
sprintf(layout_name, "%s.layout", name); sprintf(layout_name, "%s.layout", name);
@@ -547,7 +531,7 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
fd = open(name, O_RDWR|O_CREAT|O_TRUNC, 0644); fd = open(name, O_RDWR|O_CREAT|O_TRUNC, 0644);
if ( fd < 0 ) { if ( fd < 0 ) {
perror("Cannot create file"); ERROR(errno, "Cannot create output file %s", name);
return -1; return -1;
} }
@@ -558,7 +542,7 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
size = image_read(image, buf, sizeof(buf)); size = image_read(image, buf, sizeof(buf));
if ( size < 1 ) if ( size < 1 )
break; break;
WRITE_OR_FAIL(fd, buf, size); WRITE_OR_FAIL(name, fd, buf, size);
} }
close(fd); close(fd);
@@ -567,13 +551,13 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
fd = open(layout_name, O_RDWR|O_CREAT|O_TRUNC, 0644); fd = open(layout_name, O_RDWR|O_CREAT|O_TRUNC, 0644);
if ( fd < 0 ) { if ( fd < 0 ) {
perror("Cannot create file"); ERROR(errno, "Cannot create layout file %s", layout_name);
return -1; return -1;
} }
free(layout_name); free(layout_name);
WRITE_OR_FAIL(fd, image->layout, (int)strlen(image->layout)); WRITE_OR_FAIL(layout_name, fd, image->layout, (int)strlen(image->layout));
close(fd); close(fd);
@@ -581,20 +565,16 @@ int fiasco_unpack(struct fiasco * fiasco, const char * dir) {
image_list = image_list->next; image_list = image_list->next;
if ( image_list )
printf("\n");
} }
if ( dir ) { if ( dir ) {
if ( chdir(cwd) < 0 ) { if ( chdir(cwd) < 0 ) {
perror("Cannot chdir"); ERROR(errno, "Cannot change current directory back to %s", cwd);
return -1; return -1;
} }
} }
printf("\nDone\n\n");
return 0; return 0;
} }
src/global.h
+20
View File
@@ -0,0 +1,20 @@
#ifndef GLOBAL_H
#define GLOBAL_H
#include <stdio.h>
#include <string.h>
#include <errno.h>
extern int simulate;
extern int noverify;
extern int verbose;
#define VERBOSE(format, ...) do { if ( verbose ) { fprintf(stderr, format, ##__VA_ARGS__); } } while (0)
#define ERROR(errno, format, ...) do { fprintf(stderr, "Error: "); fprintf(stderr, format, ##__VA_ARGS__); if ( errno ) fprintf(stderr, ": %s\n", strerror(errno)); else fprintf(stderr, "\n"); } while (0)
#define WARNING(format, ...) do { fprintf(stderr, "Warning: "); fprintf(stderr, format, ##__VA_ARGS__); fprintf(stderr, "\n"); } while (0)
#define ALLOC_ERROR() do { ERROR(0, "Cannot allocate memory"); } while (0)
#define ALLOC_ERROR_RETURN(...) do { ALLOC_ERROR(); return __VA_ARGS__; } while (0)
#endif
src/image.c
+9 -22
View File
@@ -26,10 +26,10 @@
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include "global.h"
#include "device.h" #include "device.h"
#include "image.h" #include "image.h"
#define IMAGE_CHECK(image) do { if ( ! image || image->fd < 0 ) return; } while (0)
#define IMAGE_STORE_CUR(image) do { if ( image->is_shared_fd ) image->cur = lseek(image->fd, 0, SEEK_CUR) - image->offset; } while (0) #define IMAGE_STORE_CUR(image) do { if ( image->is_shared_fd ) image->cur = lseek(image->fd, 0, SEEK_CUR) - image->offset; } while (0)
#define IMAGE_RESTORE_CUR(image) do { if ( image->is_shared_fd ) lseek(image->fd, image->offset + image->cur, SEEK_SET); } while (0) #define IMAGE_RESTORE_CUR(image) do { if ( image->is_shared_fd ) lseek(image->fd, image->offset + image->cur, SEEK_SET); } while (0)
@@ -113,10 +113,8 @@ char * image_name_alloc_from_values(struct image * image) {
length += 1 + strlen(image->version); length += 1 + strlen(image->version);
name = calloc(1, length); name = calloc(1, length);
if ( ! name ) { if ( ! name )
perror("Alloc error"); ALLOC_ERROR_RETURN(NULL);
return NULL;
}
strcpy(name, type); strcpy(name, type);
ptr = name + strlen(name); ptr = name + strlen(name);
@@ -134,8 +132,6 @@ char * image_name_alloc_from_values(struct image * image) {
static void image_append(struct image * image, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout) { static void image_append(struct image * image, const char * type, const char * device, const char * hwrevs, const char * version, const char * layout) {
IMAGE_CHECK(image);
image->hash = image_hash_from_data(image); image->hash = image_hash_from_data(image);
image->device = device_from_string(device); image->device = device_from_string(device);
@@ -187,10 +183,8 @@ static void image_align(struct image * image) {
static struct image * image_alloc(void) { static struct image * image_alloc(void) {
struct image * image = calloc(1, sizeof(struct image)); struct image * image = calloc(1, sizeof(struct image));
if ( ! image ) { if ( ! image )
perror("Cannot allocate memory"); ALLOC_ERROR_RETURN(NULL);
return NULL;
}
return image; return image;
} }
@@ -204,7 +198,7 @@ struct image * image_alloc_from_file(const char * file, const char * type, const
image->is_shared_fd = 0; image->is_shared_fd = 0;
image->fd = open(file, O_RDONLY); image->fd = open(file, O_RDONLY);
if ( image->fd < 0 ) { if ( image->fd < 0 ) {
perror("Cannot open file"); ERROR(errno, "Cannot open image file %s", file);
free(image); free(image);
return NULL; return NULL;
} }
@@ -239,8 +233,8 @@ struct image * image_alloc_from_shared_fd(int fd, size_t size, size_t offset, ui
image_append(image, type, device, hwrevs, version, layout); image_append(image, type, device, hwrevs, version, layout);
if ( image->hash != hash ) { if ( ! noverify && image->hash != hash ) {
fprintf(stderr, "Error: Image hash mishmash (expected %#04x)\n", image->hash); ERROR(0, "Image hash mishmash (counted %#04x, got %#04x)", image->hash, hash);
image_free(image); image_free(image);
return NULL; return NULL;
} }
@@ -253,8 +247,6 @@ struct image * image_alloc_from_shared_fd(int fd, size_t size, size_t offset, ui
void image_free(struct image * image) { void image_free(struct image * image) {
IMAGE_CHECK(image);
if ( ! image->is_shared_fd ) { if ( ! image->is_shared_fd ) {
close(image->fd); close(image->fd);
image->fd = -1; image->fd = -1;
@@ -271,8 +263,6 @@ void image_free(struct image * image) {
void image_seek(struct image * image, off_t whence) { void image_seek(struct image * image, off_t whence) {
IMAGE_CHECK(image);
if ( whence > image->size ) if ( whence > image->size )
return; return;
@@ -293,7 +283,6 @@ size_t image_read(struct image * image, void * buf, size_t count) {
size_t new_count = 0; size_t new_count = 0;
size_t ret_count = 0; size_t ret_count = 0;
IMAGE_CHECK(image);
IMAGE_RESTORE_CUR(image); IMAGE_RESTORE_CUR(image);
if ( image->size < image->cur ) if ( image->size < image->cur )
@@ -337,10 +326,9 @@ size_t image_read(struct image * image, void * buf, size_t count) {
void image_list_add(struct image_list ** list, struct image * image) { void image_list_add(struct image_list ** list, struct image * image) {
IMAGE_CHECK(image);
struct image_list * last = calloc(1, sizeof(struct image_list)); struct image_list * last = calloc(1, sizeof(struct image_list));
if ( ! last ) if ( ! last )
return; ALLOC_ERROR_RETURN();
last->image = image; last->image = image;
@@ -423,7 +411,6 @@ static const char * image_types[] = {
enum image_type image_type_from_data(struct image * image) { enum image_type image_type_from_data(struct image * image) {
IMAGE_CHECK(image);
unsigned char buf[512]; unsigned char buf[512];
image_seek(image, 0); image_seek(image, 0);
src/image.h
-4
View File
@@ -82,8 +82,4 @@ enum image_type image_type_from_string(const char * type);
const char * image_type_to_string(enum image_type type); const char * image_type_to_string(enum image_type type);
int image_hwrev_is_valid(struct image * image, const char * hwrev); int image_hwrev_is_valid(struct image * image, const char * hwrev);
extern int simulate;
extern int noverify;
extern int verbose;
#endif #endif
src/main2.c
+19 -17
View File
@@ -28,6 +28,7 @@
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include "global.h"
#include "image.h" #include "image.h"
#include "fiasco2.h" #include "fiasco2.h"
#include "device.h" #include "device.h"
@@ -201,22 +202,22 @@ static void parse_image_arg(char * arg, struct image_list ** image_first) {
off_t len; off_t len;
int fd = open(layout_file, O_RDONLY); int fd = open(layout_file, O_RDONLY);
if ( fd < 0 ) { if ( fd < 0 ) {
fprintf(stderr, "Cannot open layout file %s: %s\n", layout_file, strerror(errno)); ERROR(errno, "Cannot open layout file %s", layout_file);
exit(1); exit(1);
} }
len = lseek(fd, 0, SEEK_END); len = lseek(fd, 0, SEEK_END);
if ( len == (off_t)-1 ) { if ( len == (off_t)-1 ) {
fprintf(stderr, "Cannot get file size\n"); ERROR(errno, "Cannot get size of file %s", layout_file);
exit(1); exit(1);
} }
lseek(fd, 0, SEEK_SET); lseek(fd, 0, SEEK_SET);
layout = malloc(len); layout = malloc(len);
if ( ! layout ) { if ( ! layout ) {
fprintf(stderr, "Alloc error\n"); ALLOC_ERROR();
exit(1); exit(1);
} }
if ( read(fd, layout, len) != len ) { if ( read(fd, layout, len) != len ) {
fprintf(stderr, "Cannot read layout file %s: %s\n", layout_file, strerror(errno)); ERROR(errno, "Cannot read %lu bytes from layout file %s", len, layout_file);
exit(1); exit(1);
} }
} }
@@ -227,7 +228,7 @@ static void parse_image_arg(char * arg, struct image_list ** image_first) {
free(layout); free(layout);
if ( ! image ) { if ( ! image ) {
fprintf(stderr, "Cannot load image file %s\n", file); ERROR(0, "Cannot load image file %s", file);
exit(1); exit(1);
} }
@@ -331,10 +332,7 @@ int main(int argc, char **argv) {
while ( ( c = getopt(argc, argv, optstring) ) != -1 ) { while ( ( c = getopt(argc, argv, optstring) ) != -1 ) {
switch(c) { switch (c) {
case '?':
fprintf(stderr, "error ?\n");
break;
case 'b': case 'b':
dev_boot = 1; dev_boot = 1;
dev_boot_arg = optarg; dev_boot_arg = optarg;
@@ -460,8 +458,7 @@ int main(int argc, char **argv) {
break; break;
default: default:
fprintf(stderr, "error c:%c\n", c); return 1;
break;
} }
} }
@@ -490,7 +487,7 @@ int main(int argc, char **argv) {
/* load images from files */ /* load images from files */
if ( image_first && image_fiasco ) { if ( image_first && image_fiasco ) {
fprintf(stderr, "Cannot specify together normal images and fiasco images\n"); ERROR(0, "Cannot specify normal and fiasco images together");
ret = 1; ret = 1;
goto clean; goto clean;
} }
@@ -499,7 +496,7 @@ int main(int argc, char **argv) {
if ( image_fiasco ) { if ( image_fiasco ) {
fiasco_in = fiasco_alloc_from_file(image_fiasco_arg); fiasco_in = fiasco_alloc_from_file(image_fiasco_arg);
if ( ! fiasco_in ) if ( ! fiasco_in )
fprintf(stderr, "Cannot load fiasco image file %s\n", image_fiasco_arg); ERROR(0, "Cannot load fiasco image file %s", image_fiasco_arg);
else else
image_first = fiasco_in->first; image_first = fiasco_in->first;
} }
@@ -508,7 +505,7 @@ int main(int argc, char **argv) {
if ( filter_type ) { if ( filter_type ) {
enum image_type type = image_type_from_string(filter_type_arg); enum image_type type = image_type_from_string(filter_type_arg);
if ( ! type ) { if ( ! type ) {
fprintf(stderr, "Unknown image type for filtering: %s\n", filter_type_arg); ERROR(0, "Specified unknown image type for filtering: %s", filter_type_arg);
} else { } else {
image_ptr = image_first; image_ptr = image_first;
while ( image_ptr ) { while ( image_ptr ) {
@@ -527,7 +524,7 @@ int main(int argc, char **argv) {
if ( filter_device ) { if ( filter_device ) {
enum device device = device_from_string(filter_device_arg); enum device device = device_from_string(filter_device_arg);
if ( ! device ) { if ( ! device ) {
fprintf(stderr, "Unknown device for filtering: %s\n", filter_device_arg); ERROR(0, "Specified unknown device for filtering: %s", filter_device_arg);
} else { } else {
image_ptr = image_first; image_ptr = image_first;
while ( image_ptr ) { while ( image_ptr ) {
@@ -647,7 +644,7 @@ int main(int argc, char **argv) {
while ( image_ptr ) { while ( image_ptr ) {
struct image_list * next = image_ptr->next; struct image_list * next = image_ptr->next;
if ( image_ptr->image->type == IMAGE_UNKNOWN || image_ptr->image->device == DEVICE_UNKNOWN ) { if ( image_ptr->image->type == IMAGE_UNKNOWN || image_ptr->image->device == DEVICE_UNKNOWN ) {
printf("!!Removing unknown image!!\n"); WARNING("Removing unknown image (specified by %s %s)", image_ptr->image->orig_filename ? "file" : "fiasco", image_ptr->image->orig_filename ? image_ptr->image->orig_filename : "image");
image_list_unlink(image_ptr); image_list_unlink(image_ptr);
free(image_ptr); free(image_ptr);
if ( image_ptr == image_first ) if ( image_ptr == image_first )
@@ -662,10 +659,15 @@ int main(int argc, char **argv) {
/* generate fiasco */ /* generate fiasco */
if ( fiasco_gen ) { if ( fiasco_gen ) {
char * swver = strchr(fiasco_gen_arg, '%');
if ( swver )
*(swver++) = 0;
fiasco_out = fiasco_alloc_empty(); fiasco_out = fiasco_alloc_empty();
if ( ! fiasco_out ) { if ( ! fiasco_out ) {
fprintf(stderr, "Cannot write images to fiasco file %s\n", fiasco_gen_arg); ERROR(0, "Cannot write images to fiasco file %s", fiasco_gen_arg);
} else { } else {
if ( swver )
strcpy(fiasco_out->swver, swver);
fiasco_out->first = image_first; fiasco_out->first = image_first;
fiasco_write_to_file(fiasco_out, fiasco_gen_arg); fiasco_write_to_file(fiasco_out, fiasco_gen_arg);
fiasco_out->first = NULL; fiasco_out->first = NULL;