2006/11/23, Bryan Kadzban <[EMAIL PROTECTED]>:
Christian Hirsch wrote:
> Now I have the problem that I don't know how to creat a *.bin image
> which I can download on the router.
I have never done it this way, but the OpenWRT project has some kind of
development environment that you can use to build your own OpenWRT
packages. I think they used to have the ability to create a full .trx
firmware image from that environment too (the .bin is just the .trx with
a header that the WRT uses to verify that the firmware is for the
correct device; I don't know what has to be in the header though).
You could perhaps pull that down and see how they do it. It'd get you
at least part of the way there.
Basically, a firmware file consists of 2 parts:
- Kernel
- Root filesystem (created by mksquashfs or mkfs.jffs2)
The kernel can be v2.4.30 or v2.6.X, depends wether you want wireless
working or not. I have made it working on both kernels, but it is VERY
RECOMMENDED to create a serial console, to see when and where things
go wrong.
Compile these 2 with 'gcc addpattern.c -o addpattern' and 'gcc trx.c
-o trx', then issue the following commands:
trx -o foo.trx -a 0x10000 kernel rootfs
addpattern -4 -p W54G -v v4.30.8 -i foo.trx -o foo.bin -g
Then your firmware file is 'foo.bin'.
I too used OpenWRT to find out a lot, it was a great help.
Wireless support is a harder issue though, haven't fully tackled that
problem. In the end I've made CLFS Embedded working on it, but it
requires custom bootscripts and patches to the kernel..
To add a serial or USB console:
http://wiki.openwrt.org/OpenWrtDocs/Customizing/Hardware/Serial_Console
The toolchain made in CLFS Embedded can be used for it, target triplet
is mipsel-unknown-linux-uclibc.
To compile a working kernel will be a post of it's own.
/*
* Copyright (C) 2004 Manuel Novoa III <[EMAIL PROTECTED]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* July 29, 2004
*
* This is a hacked replacement for the 'addpattern' utility used to
* create wrt54g .bin firmware files. It isn't pretty, but it does
* the job for me.
*
* Extensions:
* -v allows setting the version string on the command line.
* -{0|1} sets the (currently ignored) hw_ver flag in the header
* to 0 or 1 respectively.
*/
/* January 12, 2005
*
* Modified by rodent at rodent dot za dot net
* Support added for the new WRT54G v2.2 and WRT54GS v1.1 "flags"
* Without the flags set to 0x7, the above units will refuse to flash.
*
* Extensions:
* -{0|1|2} sets {0|1} sets hw_ver flag to 0/1. {2} sets hw_ver to 1
* and adds the new hardware "flags" for the v2.2/v1.1 units
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
/**********************************************************************/
#define CODE_ID "U2ND" /* from code_pattern.h */
#define CODE_PATTERN "W54S" /* from code_pattern.h */
#define PBOT_PATTERN "PBOT"
#define CYBERTAN_VERSION "v3.37.2" /* from cyutils.h */
/* WRT54G v2.2 and WRT54GS v1.1 "flags" (from 3.37.32 firmware cyutils.h) */
#define SUPPORT_4712_CHIP 0x0001
#define SUPPORT_INTEL_FLASH 0x0002
#define SUPPORT_5325E_SWITCH 0x0004
struct code_header { /* from cyutils.h */
char magic[4];
char res1[4]; /* for extra magic */
char fwdate[3];
char fwvern[3];
char id[4]; /* U2ND */
char hw_ver; /* 0: for 4702, 1: for 4712 -- new in 2.04.3 */
char unused;
unsigned char flags[2]; /* SUPPORT_ flags new for 3.37.2 (WRT54G v2.2 and WRT54GS v1.1) */
unsigned char res2[10];
} ;
/**********************************************************************/
void usage(void) __attribute__ (( __noreturn__ ));
void usage(void)
{
fprintf(stderr, "Usage: addpattern [-i trxfile] [-o binfile] [-p pattern] [-g] [-b] [-v v#.#.#] [-{0|1|2|4}]\n");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
char buf[1024]; /* keep this at 1k or adjust garbage calc below */
struct code_header *hdr;
FILE *in = stdin;
FILE *out = stdout;
char *ifn = NULL;
char *ofn = NULL;
char *pattern = CODE_PATTERN;
char *pbotpat = PBOT_PATTERN;
char *version = CYBERTAN_VERSION;
int gflag = 0;
int pbotflag = 0;
int c;
int v0, v1, v2;
size_t off, n;
time_t t;
struct tm *ptm;
fprintf(stderr, "mjn3's addpattern replacement - v0.81\n");
hdr = (struct code_header *) buf;
memset(hdr, 0, sizeof(struct code_header));
while ((c = getopt(argc, argv, "i:o:p:gbv:0124")) != -1) {
switch (c) {
case 'i':
ifn = optarg;
break;
case 'o':
ofn = optarg;
break;
case 'p':
pattern = optarg;
break;
case 'g':
gflag = 1;
break;
case 'b':
pbotflag = 1;
break;
case 'v': /* extension to allow setting version */
version = optarg;
break;
case '0':
hdr->hw_ver = 0;
break;
case '1':
hdr->hw_ver = 1;
break;
case '2': /* new 54G v2.2 and 54GS v1.1 flags */
hdr->hw_ver = 1;
hdr->flags[0] |= SUPPORT_4712_CHIP;
hdr->flags[0] |= SUPPORT_INTEL_FLASH;
hdr->flags[0] |= SUPPORT_5325E_SWITCH;
break;
case '4':
/* V4 firmware sets the flags to 0x1f */
hdr->hw_ver = 0;
hdr->flags[0] = 0x1f;
break;
default:
usage();
}
}
if (optind != argc) {
fprintf(stderr, "illegal arg \"%s\"\n", argv[optind]);
usage();
}
if (strlen(pattern) != 4) {
fprintf(stderr, "illegal pattern \"%s\": length != 4\n", pattern);
usage();
}
if (ifn && !(in = fopen(ifn, "r"))) {
fprintf(stderr, "can not open \"%s\" for reading\n", ifn);
usage();
}
if (ofn && !(out = fopen(ofn, "w"))) {
fprintf(stderr, "can not open \"%s\" for writing\n", ofn);
usage();
}
if (time(&t) == (time_t)(-1)) {
fprintf(stderr, "time call failed\n");
return EXIT_FAILURE;
}
ptm = localtime(&t);
if (3 != sscanf(version, "v%d.%d.%d", &v0, &v1, &v2)) {
fprintf(stderr, "bad version string \"%s\"\n", version);
return EXIT_FAILURE;
}
memcpy(&hdr->magic, pattern, 4);
if (pbotflag)
memcpy(&hdr->res1, pbotpat, 4);
hdr->fwdate[0] = ptm->tm_year % 100;
hdr->fwdate[1] = ptm->tm_mon + 1;
hdr->fwdate[2] = ptm->tm_mday;
hdr->fwvern[0] = v0;
hdr->fwvern[1] = v1;
hdr->fwvern[2] = v2;
memcpy(&hdr->id, CODE_ID, strlen(CODE_ID));
off = sizeof(struct code_header);
fprintf(stderr, "writing firmware v%d.%d.%d on %d/%d/%d (y/m/d)\n",
v0, v1, v2,
hdr->fwdate[0], hdr->fwdate[1], hdr->fwdate[2]);
while ((n = fread(buf + off, 1, sizeof(buf)-off, in) + off) > 0) {
off = 0;
if (n < sizeof(buf)) {
if (ferror(in)) {
FREAD_ERROR:
fprintf(stderr, "fread error\n");
return EXIT_FAILURE;
}
if (gflag) {
gflag = sizeof(buf) - n;
memset(buf + n, 0xff, gflag);
fprintf(stderr, "adding %d bytes of garbage\n", gflag);
n = sizeof(buf);
}
}
if (!fwrite(buf, n, 1, out)) {
FWRITE_ERROR:
fprintf(stderr, "fwrite error\n");
return EXIT_FAILURE;
}
}
if (ferror(in)) {
goto FREAD_ERROR;
}
if (fflush(out)) {
goto FWRITE_ERROR;
}
fclose(in);
fclose(out);
return EXIT_SUCCESS;
}
/*
* Copyright (C) 2004 Manuel Novoa III <[EMAIL PROTECTED]>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* July 29, 2004
*
* This is a hacked replacement for the 'trx' utility used to create
* wrt54g .trx firmware files. It isn't pretty, but it does the job
* for me.
*
* As an extension, you can specify a larger maximum length for the
* .trx file using '-m'. It will be rounded up to be a multiple of 4K.
* NOTE: This space will be malloc()'d.
*
* August 16, 2004
*
* Sigh... Make it endian-neutral.
*
* TODO: Support '-b' option to specify offsets for each file.
*
* February 19, 2005 - mbm
*
* Add -a (align offset) and -b (absolute offset)
*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#if defined(__APPLE__)
#include <machine/endian.h>
#include <machine/byte_order.h>
#define __BYTE_ORDER BYTE_ORDER
#define __BIG_ENDIAN BIG_ENDIAN
#define bswap_16(x) NXSwapShort(x)
#define bswap_32(x) NXSwapInt(x)
#define bswap_64(x) NXSwapLongLong(x)
#else
#include <endian.h>
#include <byteswap.h>
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
#define STORE32_LE(X) bswap_32(X)
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define STORE32_LE(X) (X)
#else
#error unkown endianness!
#endif
uint32_t crc32buf(char *buf, size_t len);
/**********************************************************************/
/* from trxhdr.h */
#define TRX_MAGIC 0x30524448 /* "HDR0" */
#define TRX_VERSION 1
#define TRX_MAX_LEN 0x5A0000
#define TRX_NO_HEADER 1 /* Do not write TRX header */
struct trx_header {
uint32_t magic; /* "HDR0" */
uint32_t len; /* Length of file including header */
uint32_t crc32; /* 32-bit CRC from flag_version to end of file */
uint32_t flag_version; /* 0:15 flags, 16:31 version */
uint32_t offsets[3]; /* Offsets of partitions from start of header */
};
/**********************************************************************/
void usage(void) __attribute__ (( __noreturn__ ));
void usage(void)
{
fprintf(stderr, "Usage: trx [-o outfile] [-m maxlen] [-a align] [-b offset] [-f file] [-f file [-f file]]\n");
exit(EXIT_FAILURE);
}
int main(int argc, char **argv)
{
FILE *out = stdout;
FILE *in;
char *ofn = NULL;
char *buf;
char *e;
int c, i;
size_t n;
uint32_t cur_len;
unsigned long maxlen = TRX_MAX_LEN;
struct trx_header *p;
fprintf(stderr, "mjn3's trx replacement - v0.81.1\n");
if (!(buf = malloc(maxlen))) {
fprintf(stderr, "malloc failed\n");
return EXIT_FAILURE;
}
p = (struct trx_header *) buf;
p->magic = STORE32_LE(TRX_MAGIC);
cur_len = sizeof(struct trx_header);
p->flag_version = STORE32_LE((TRX_VERSION << 16));
in = NULL;
i = 0;
while ((c = getopt(argc, argv, "-:o:m:a:b:f:")) != -1) {
switch (c) {
case 'f':
case 1:
p->offsets[i++] = STORE32_LE(cur_len);
if (!(in = fopen(optarg, "r"))) {
fprintf(stderr, "can not open \"%s\" for reading\n", optarg);
usage();
}
n = fread(buf + cur_len, 1, maxlen - cur_len, in);
if (!feof(in)) {
fprintf(stderr, "fread failure or file \"%s\" too large\n",optarg);
fclose(in);
return EXIT_FAILURE;
}
fclose(in);
#undef ROUND
#define ROUND 4
if (n & (ROUND-1)) {
memset(buf + cur_len + n, 0, ROUND - (n & (ROUND-1)));
n += ROUND - (n & (ROUND-1));
}
cur_len += n;
break;
case 'o':
ofn = optarg;
if (ofn && !(out = fopen(ofn, "w"))) {
fprintf(stderr, "can not open \"%s\" for writing\n", ofn);
usage();
}
break;
case 'm':
errno = 0;
maxlen = strtoul(optarg, &e, 0);
if (errno || (e == optarg) || *e) {
fprintf(stderr, "illegal numeric string\n");
usage();
}
#undef ROUND
#define ROUND 0x1000
if (maxlen & (ROUND-1)) {
maxlen += (ROUND - (maxlen & (ROUND-1)));
}
if (maxlen < ROUND) {
fprintf(stderr, "maxlen too small (or wrapped)\n");
usage();
}
if (maxlen > TRX_MAX_LEN) {
fprintf(stderr, "WARNING: maxlen exceeds default maximum! Beware of overwriting nvram!\n");
}
if (!(buf = realloc(buf,maxlen))) {
fprintf(stderr, "realloc failed");
return EXIT_FAILURE;
}
break;
case 'a':
errno = 0;
n = strtoul(optarg, &e, 0);
if (errno || (e == optarg) || *e) {
fprintf(stderr, "illegal numeric string\n");
usage();
}
if (cur_len & (n-1)) {
n = n - (cur_len & (n-1));
memset(buf + cur_len, 0, n);
cur_len += n;
}
break;
case 'b':
errno = 0;
n = strtoul(optarg, &e, 0);
if (errno || (e == optarg) || *e) {
fprintf(stderr, "illegal numeric string\n");
usage();
}
if (n < cur_len) {
fprintf(stderr, "WARNING: current length exceeds -b %d offset\n",n);
} else {
memset(buf + cur_len, 0, n - cur_len);
cur_len = n;
}
break;
default:
usage();
}
}
if (!in) {
fprintf(stderr, "we require atleast one filename\n");
usage();
}
#undef ROUND
#define ROUND 0x1000
n = cur_len & (ROUND-1);
if (n) {
memset(buf + cur_len, 0, ROUND - n);
cur_len += ROUND - n;
}
p->crc32 = crc32buf((char *) &p->flag_version,
cur_len - offsetof(struct trx_header, flag_version));
p->crc32 = STORE32_LE(p->crc32);
p->len = STORE32_LE(cur_len);
if (!fwrite(buf, cur_len, 1, out) || fflush(out)) {
fprintf(stderr, "fwrite failed\n");
return EXIT_FAILURE;
}
fclose(out);
return EXIT_SUCCESS;
}
/**********************************************************************/
/* The following was grabbed and tweaked from the old snippets collection
* of public domain C code. */
/**********************************************************************\
|* Demonstration program to compute the 32-bit CRC used as the frame *|
|* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
|* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
|* protocol). The 32-bit FCS was added via the Federal Register, *|
|* 1 June 1982, p.23798. I presume but don't know for certain that *|
|* this polynomial is or will be included in CCITT V.41, which *|
|* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
|* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
|* errors by a factor of 10^-5 over 16-bit FCS. *|
\**********************************************************************/
/* Copyright (C) 1986 Gary S. Brown. You may use this program, or
code or tables extracted from it, as desired without restriction.*/
/* First, the polynomial itself and its table of feedback terms. The */
/* polynomial is */
/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
/* Note that we take it "backwards" and put the highest-order term in */
/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
/* the MSB being 1. */
/* Note that the usual hardware shift register implementation, which */
/* is what we're using (we're merely optimizing it by doing eight-bit */
/* chunks at a time) shifts bits into the lowest-order term. In our */
/* implementation, that means shifting towards the right. Why do we */
/* do it this way? Because the calculated CRC must be transmitted in */
/* order from highest-order term to lowest-order term. UARTs transmit */
/* characters in order from LSB to MSB. By storing the CRC this way, */
/* we hand it to the UART in the order low-byte to high-byte; the UART */
/* sends each low-bit to hight-bit; and the result is transmission bit */
/* by bit from highest- to lowest-order term without requiring any bit */
/* shuffling on our part. Reception works similarly. */
/* The feedback terms table consists of 256, 32-bit entries. Notes: */
/* */
/* 1. The table can be generated at runtime if desired; code to do so */
/* is shown later. It might not be obvious, but the feedback */
/* terms simply represent the results of eight shift/xor opera- */
/* tions for all combinations of data and CRC register values. */
/* */
/* 2. The CRC accumulation logic is the same for all CRC polynomials, */
/* be they sixteen or thirty-two bits wide. You simply choose the */
/* appropriate table. Alternatively, because the table can be */
/* generated at runtime, you can start by generating the table for */
/* the polynomial in question and use exactly the same "updcrc", */
/* if your application needn't simultaneously handle two CRC */
/* polynomials. (Note, however, that XMODEM is strange.) */
/* */
/* 3. For 16-bit CRCs, the table entries need be only 16 bits wide; */
/* of course, 32-bit entries work OK if the high 16 bits are zero. */
/* */
/* 4. The values must be right-shifted by eight bits by the "updcrc" */
/* logic; the shift must be unsigned (bring in zeroes). On some */
/* hardware you could probably optimize the shift in assembler by */
/* using byte-swap instructions. */
static const uint32_t crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
#define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8))
uint32_t crc32buf(char *buf, size_t len)
{
uint32_t crc;
crc = 0xFFFFFFFF;
for ( ; len; --len, ++buf)
{
crc = UPDC32(*buf, crc);
}
return crc;
}
_______________________________________________
Clfs-dev mailing list
[email protected]
http://lists.cross-lfs.org/cgi-bin/mailman/listinfo/clfs-dev
