pakwif.c-Dateireferenz

#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>

Include-Abhängigkeitsdiagramm für pakwif.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	__attribute__
struct	pak_t

Makrodefinitionen
#define	CRYPT1_SIZE   512
#define	CRYPT2_SIZE   513
#define	HEADER_SIZE   (sizeof(header_t)/sizeof(char))
#define	BLKSIZE   0x1000

Typdefinitionen
typedef unsigned short	uint16

Funktionen
int	crypt_fwrite (void *buf, int len, FILE *f)
int	crypt_fread (void *buf, int len, FILE *f)
pak_t *	pak_create (char *filename)
uint32_t	checksumm_init ()
uint32_t	checksumm_update (uint32_t cs, char *buf, int len)
int	pak_add_file (pak_t *p, char *type, char *desc, char *infirname, char *filename, uint32_t baseaddr)
int	pak_add_4byteid (pak_t *p, char *desc, char *name, uint32_t id)
void	pak_close (pak_t *p)
int	usage ()
int	main (int argc, char **argv)

Variablen
unsigned char	crypt1 [512]
unsigned char	crypt2 [513]

Makro-Dokumentation

#define BLKSIZE   0x1000

Definiert in Zeile 296 der Datei pakwif.c.

#define CRYPT1_SIZE   512

Definiert in Zeile 151 der Datei pakwif.c.

#define CRYPT2_SIZE   513

Definiert in Zeile 152 der Datei pakwif.c.

#define HEADER_SIZE   (sizeof(header_t)/sizeof(char))

Definiert in Zeile 154 der Datei pakwif.c.

Dokumentation der benutzerdefinierten Typen

typedef unsigned short uint16

Definiert in Zeile 15 der Datei pakwif.c.

Dokumentation der Funktionen

uint32_t checksumm_init

(

)

Definiert in Zeile 278 der Datei pakwif.c.

{
    return 0;
}

uint32_t checksumm_update	(	uint32_t	cs,
		char *	buf,
		int	len
	)

Definiert in Zeile 284 der Datei pakwif.c.

{
    int i;

    for (i=0;i<len/2;i++)
        cs+=((unsigned short*)buf)[i];  
    if (len&1)
        cs+=buf[len-1]; 

    return cs;
}

int crypt_fread	(	void *	buf,
		int	len,
		FILE *	f
	)

Definiert in Zeile 192 der Datei pakwif.c.

{
    unsigned char cbuf[1024];
    int r, rtot, start, towr, i, c1, c2;

    start = ftell(f);
    rtot = 0;

    c1 = start % CRYPT1_SIZE;
    c2 = start % CRYPT2_SIZE;

    if (len>1024)
    towr = 1024;
    else
    towr = len;
    r = fread(cbuf,1,towr,f);

    while (len>0 && r>0){
    for (i=0;i<r;i++){
        ((unsigned char*)buf)[i+rtot] = ((unsigned char*)cbuf)[i] ^ crypt1[c1++] ^ crypt2[c2++];

        if (c1 >= CRYPT1_SIZE)
        c1 = 0;
        if (c2 >= CRYPT2_SIZE)
        c2 = 0;
    }

    rtot += r;
    len -= r;

    if (len>1024)
        towr = 1024;
    else
        towr = len;
    r = fread(cbuf,1,towr,f);
    if (r<0)
        return r;
    }

    return rtot;
}

int crypt_fwrite	(	void *	buf,
		int	len,
		FILE *	f
	)

Definiert in Zeile 156 der Datei pakwif.c.

{
    unsigned char cbuf[1024];
    int r, rtot, start, towr, i, c1, c2;

    start = ftell(f);
    rtot = 0;

    c1 = start % CRYPT1_SIZE;
    c2 = start % CRYPT2_SIZE;

    while (len>0){
    if (len>1024)
        towr = 1024;
    else
        towr = len;

    for (i=0;i<towr;i++){
        cbuf[i] = ((unsigned char*)buf)[i+rtot] ^ crypt1[c1++] ^ crypt2[c2++];

        if (c1 >= CRYPT1_SIZE)
        c1 = 0;
        if (c2 >= CRYPT2_SIZE)
        c2 = 0;
    }

    r = fwrite(cbuf,1,towr,f);
    if (r<0)
        return r;
    rtot += r;
    len -= r;
    }

    return rtot;
}

int main	(	int	argc,
		char **	argv
	)

Definiert in Zeile 403 der Datei pakwif.c.

{
    char cbuf[100];
    pak_t *p;
    char *fir_fn;
    char *wif_fn;
    int camid, ver;


    if (argc < 4){
        usage();
    }

    fir_fn = argv[1];
    wif_fn = argv[2];
    camid = strtoul(argv[3], NULL, 0);

    if (argc == 5){
        ver = strtoul(argv[4], NULL, 0);
    } else {
        ver = 0x01000100;
    }

    printf("Building FIR for camera %04X ver %08X\n", camid, ver);

    p = pak_create(fir_fn);

    sprintf(cbuf, "0x%08X", ver);
    pak_add_4byteid(p,"VersionID", cbuf, ver);
    pak_add_4byteid(p,"VersionCheck", "0(no)", 0);
    pak_add_4byteid(p,"CipherToLog", "1(yes)", 1);

    pak_add_file(p,"PROGRAM",  "Program", "WriterInFIR.bin", wif_fn, 0xffffffff);
//  pak_add_file(p,"UPGRADEPROGRAM",  "New", "PRIMARY.BIN", 0);
//  pak_add_file(p,"UPGRADEPROPERTY", "Faexe.bin", "Faexe.bin", 0xffbc0000);
//  pak_add_file(p,"UPGRADEPROPERTY", "ImgTbl.bin", "ImgTbl.bin", 0xffbe0000);
//  pak_add_file(p,"UPGRADEPROPERTY", "UIRes.bin", "UIRes.bin", 0xffd80000);
//  pak_add_file(p,"UPGRADEPROPERTY", "UsrSet.BIN", "UsrSet.BIN", 0xff800000);

    pak_add_4byteid(p,"ModelID", "0x01660000", 0x01660000);

    sprintf(cbuf, "0x%04X", camid);
    pak_add_4byteid(p,"ProductID", cbuf, camid);

    pak_close(p);
    return 0;
}

int pak_add_4byteid	(	pak_t *	p,
		char *	desc,
		char *	name,
		uint32_t	id
	)

Definiert in Zeile 354 der Datei pakwif.c.

{
    header_t h;

    memset(&h, 0, HEADER_SIZE);
    strcpy(h.type, "4BYTEID");
    strcpy(h.description, desc);
    strcpy(h.name, name);
    h.length = 4;
    h.checksumm = 0;

    crypt_fwrite(&h,HEADER_SIZE,p->f);
    crypt_fwrite(&id,4,p->f);

    return 0;
}

int pak_add_file	(	pak_t *	p,
		char *	type,
		char *	desc,
		char *	infirname,
		char *	filename,
		uint32_t	baseaddr
	)

Definiert in Zeile 297 der Datei pakwif.c.

{
    char fnbuff[100];
    char buff[BLKSIZE];
    header_t h;
    FILE *inf;
    char *fnp;
    long filelen;
    int bcnt;

    inf = fopen(filename, "r+b");
    if (inf == NULL){
        return -1;
    }

    memset(&h, 0, HEADER_SIZE);

    fseek(inf, 0, SEEK_END);
    filelen = ftell(inf);
    fseek(inf, 0, SEEK_SET);

    fnp = strrchr(infirname, '/');
    if (fnp != NULL){
        strncpy(fnbuff, fnp+1, 31);
    } else
        strncpy(fnbuff, infirname, 31);
    fnbuff[31] = 0;

    fseek(p->f, HEADER_SIZE, SEEK_CUR);
    h.checksumm = checksumm_init();

    /* write data */
    bcnt = fread(buff, 1, BLKSIZE, inf);
    while (bcnt>0){
        h.checksumm = checksumm_update(h.checksumm, buff, bcnt);
        crypt_fwrite(buff, bcnt, p->f);
        bcnt = fread(buff, 1, BLKSIZE, inf);
    }

    /* write header */
    fseek(p->f, -filelen-HEADER_SIZE, SEEK_CUR);

    strcpy(h.type, type);
    strcpy(h.description, desc);
    strcpy(h.name, fnbuff);

    h.length = filelen;
    h.checksumm = (baseaddr==0xffffffff)?h.checksumm:baseaddr;
    crypt_fwrite(&h,HEADER_SIZE,p->f);
    fseek(p->f, filelen, SEEK_CUR);


    fclose(inf);
    return 0;
}

void pak_close

(

pak_t *

p)

Definiert in Zeile 372 der Datei pakwif.c.

{
    char buff[BLKSIZE];
    uint32_t len;
    uint32_t cs;
    int bcnt;

    len = ftell(p->f);
    cs = checksumm_init();
    fseek(p->f, HEADER_SIZE, SEEK_SET);

    bcnt = crypt_fread(buff, BLKSIZE, p->f);
    while (bcnt>0){
        cs = checksumm_update(cs, buff, bcnt);
        bcnt = crypt_fread(buff, BLKSIZE, p->f);
    }

    fseek(p->f, 32*3, SEEK_SET);
    crypt_fwrite(&len, 4, p->f);
    crypt_fwrite(&cs, 4, p->f);

    fclose(p->f);
    free(p);
}

pak_t* pak_create

(

char *

filename)

Definiert in Zeile 240 der Datei pakwif.c.

{
    char fnbuff[100];
    char *fnp;
    FILE *f;
    pak_t *p;
    header_t h;

    f = fopen(filename, "w+b");
    if(f == NULL){
        return NULL;
    }

    p = malloc(sizeof(pak_t));
    p->f = f;

    fnp = strrchr(filename, '/');
    if (fnp != NULL){
        strncpy(fnbuff, fnp+1, 31);
    } else
        strncpy(fnbuff, filename, 31);
    fnbuff[31] = 0;
    

    memset(&h, 0, HEADER_SIZE);

    strcpy(h.type, "HEADER");
    strcpy(h.description, "UpgradeFirmSignature");
    strcpy(h.name, fnbuff);

    h.length = -1;
    h.checksumm = -1;

    crypt_fwrite(&h,HEADER_SIZE,f);

    return p;
}

int usage

(

void

)

Definiert in Zeile 397 der Datei pakwif.c.

{
    printf("pakfir <out_fir_file> <in_wif_file> <camera_id> [version]\n");
    exit(1);
}

Variablen-Dokumentation

unsigned char crypt1[512]

Definiert in Zeile 17 der Datei pakwif.c.

unsigned char crypt2[513]

Definiert in Zeile 84 der Datei pakwif.c.