Freetz für 6490?

Index: unpack-kernel
===================================================================
--- unpack-kernel       (Revision 14346)
+++ unpack-kernel       (Arbeitskopie)
@@ -184,31 +184,31 @@
 }
 
 getTiRecordLen() {
-       local tiRecordOfset=$1
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + 4))
+       local tiRecordOffset=$1
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + 4))
 }
 
 getLoadAddr() {
-       local tiRecordOfset=$1
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + 8))
+       local tiRecordOffset=$1
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + 8))
 }
 
 getEntryAddr() {
-       local tiRecordOfset=$1
-       local tiRecordLen=$(getTiRecordLen $tiRecordOfset)
+       local tiRecordOffset=$1
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)
 
-       local tiRecordEntryZero=$(getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 16)))
+       local tiRecordEntryZero=$(getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 16)))
        if [ "$tiRecordEntryZero" -ne 0 ]; then                                                                                                                                                                  
                echo >&2 "WARNING: entry address is expected to be prefixed with one 32-bit zero word"                                                                                                           
        fi                                                                                                                                                                                                       
                                                                                                                                                                                                                 
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 20))                                                                                                                                    
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 20))                                                                                                                                   
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
 getTiRecordChecksum() {                                                                                                                                                                                         
-       local tiRecordOfset=$1                                                                                                                                                                                   
-       local tiRecordLen=$(getTiRecordLen $tiRecordOfset)                                                                                                                                                       
-       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOfset + tiRecordLen  + 12))                                                                                                                                    
+       local tiRecordOffset=$1                                                                                                                                                                                  
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)                                                                                                                                                      
+       getLEu32AtOffset "$INPUT_FILE" $((tiRecordOffset + tiRecordLen  + 12))                                                                                                                                   
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
                                                                                                                                                                                                                 
@@ -220,7 +220,7 @@                                                                                                                                                                                              
 #                                                                                                                                                                                                               
 # returns offset of the magic sequence by setting the global variable TI_RECORD_OFFSET                                                                                                                          
 #                                                                                                                                                                                                               
-findAndProcessTiRecord() {                                                                                                                                                                                      
+findAndUnLzmaTiRecord() {                                                                                                                                                                                       
        local magic="$1"                                                                                                                                                                                         
        local tiRecordName="$2"                                                                                                                                                                                  
        local tiRecordPrefix=$(echo -n "$tiRecordName" | tr -c '_a-zA-Z0-9' '_')                                                                                                                                 
@@ -252,15 +252,62 @@                                                                                                                                                                                            
        TI_RECORD_OFFSET=$tiRecordOffset                                                                                                                                                                         
 }                                                                                                                                                                                                               
                                                                                                                                                                                                                 
+#                                                                                                                                                                                                               
+# $1 - magic sequence (in little-endian notation)                                                                                                                                                               
+# $2 - TI-record name                                                                                                                                                                                           
+# $3 - name of the file output to be written to                                                                                                                                                                 
+# $4 - tight lower bound of the magic sequence match, optional                                                                                                                                                  
+#                                                                                                                                                                                                               
+# returns offset of the magic sequence by setting the global variable TI_RECORD_OFFSET                                                                                                                          
+#                                                                                                                                                                                                               
+findAndExtractTiRecord() {                                                                                                                                                                                      
+       local magic="$1"                                                                                                                                                                                         
+       local tiRecordName="$2"                                                                                                                                                                                  
+       local tiRecordPrefix=$(echo -n "$tiRecordName" | tr -c '_a-zA-Z0-9' '_')
+       tiRecordPrefix=${tiRecordPrefix}${tiRecordPrefix:+.}
+       local outputFile="$3"
+       local lowerBound="$4"
+
+       # unset return value
+       TI_RECORD_OFFSET=""
+
+       local tiRecordOffset="", tiRecordLzmaRecordOffset=""
+       { tiRecordOffset=$(getDecOffsetOf1stMagicSequenceMatch $magic "$tiRecordName" 1 $lowerBound); } || return 1
+       echo "${tiRecordPrefix}RecordOffset=$(print08X $tiRecordOffset)"
+       local tiRecordLoadAddr=$(getLoadAddr $tiRecordOffset)
+       echo "${tiRecordPrefix}LoadAddress=$(print08X $tiRecordLoadAddr)"
+       local tiRecordEntryAddr=$(getEntryAddr $tiRecordOffset)
+       echo "${tiRecordPrefix}EntryAddress=$(print08X $tiRecordEntryAddr)"
+       local tiRecordLen=$(getTiRecordLen $tiRecordOffset)
+       echo "${tiRecordPrefix}RecordLength=$(print08X $tiRecordLen)"
+       local tiRecordChecksum=$(getTiRecordChecksum $tiRecordOffset)
+       echo "${tiRecordPrefix}RecordChecksum=$(print08X $tiRecordChecksum)"
+
+       if [ "$METHOD" == "info" ]; then
+               return 0
+       fi
+
+       dd if="$INPUT_FILE" bs=1 skip=$(($tiRecordOffset + 12)) count=$(($tiRecordLen)) of="$outputFile" 2>/dev/null
+
+       [ $? -ne 0 ] && { echo >&2 "ERROR: failed to extract kernel"; return 1; }
+
+       # set return value
+       TI_RECORD_OFFSET=$tiRecordOffset
+}
+
 ##
 
 TI_AR7_MAGIC=FEED1281
 DUAL_KERNEL_MAGIC=FEED9112
 TI_AR7_2ND_MAGIC=FEEDB007
+TI_PUMA6_MAGIC=FEED8112
 EVA_LZMA_RECORD_MAGIC=075A0201
 
 # 1st kernel (all boxes)
-findAndProcessTiRecord $TI_AR7_MAGIC "TI-AR7" "$OUTPUT_FILE" || exit 1
+if ! findAndUnLzmaTiRecord $TI_AR7_MAGIC "TI-AR7" "$OUTPUT_FILE"; then
+       findAndExtractTiRecord $TI_PUMA6_MAGIC "TI-AR7" "$OUTPUT_FILE" || exit 1
+       exit 0
+fi
 feed1281_Offset=$TI_RECORD_OFFSET
 
 # 2nd kernel (GRX5 boxes only)
@@ -285,6 +332,6 @@
        feedb007_LowerBound=$((feed1281_Offset + $(getTiRecordLen $feed1281_Offset)  + 24))
        feedb007_LowerBound=$((feedb007_LowerBound + (4 - feedb007_LowerBound%4)%4)) # pad to a 4-byte boundary
 
-       findAndProcessTiRecord $TI_AR7_2ND_MAGIC "TI-AR7-2ND" "${OUTPUT_FILE}.2ND" $((feedb007_LowerBound-1)) || exit 1
+       findAndUnLzmaTiRecord $TI_AR7_2ND_MAGIC "TI-AR7-2ND" "${OUTPUT_FILE}.2ND" $((feedb007_LowerBound-1)) || exit 1
        feedb007_Offset=$TI_RECORD_OFFSET
 fi

/*
    eva2bzimage 
    Copyright (C) 2017  Sebastian Frei <[email protected]>
    derived from eva2lzma, derived from
    lzma2eva - convert lzma-compressed file to AVM EVA bootloader format
    Copyright (C) 2007  Enrik Berkhan <[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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
*/

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

void
usage(void)
{
  fprintf(stderr, "usage: eva2bzimage <evafile> <bzimagefile>\n");
  exit(1);
}

void
pexit(const char *msg)
{
  perror(msg);
  exit(1);
}

int
main(int argc, char *argv[])
{

  FILE *in = NULL, *out = NULL;
  uint8_t buf;

  uint32_t magic = 0xfeed1281L;
  uint32_t reclength = 0;
  uint32_t loadaddress = 0;
  uint32_t checksum = 0;
  uint32_t checksum_calc = 0;
  uint32_t compsize = 0;

  uint32_t zero = 0;
  uint32_t entry = 0;

  if (argc != 3)
    usage();

  /* "parse" command line */
  in = fopen(argv[1], "rb");
  if (!in)
    pexit("fopen");
  out = fopen(argv[2], "w+b");
  if (!out)
    pexit("fopen");

  /* read EVA header */
  if (1 != fread(&magic, sizeof magic, 1, in))
    pexit("fread");
  printf("MAGIC=0x%X\n", magic);
  if (1 != fread(&reclength, sizeof reclength, 1, in))
    pexit("fread");
  printf("RECLENGHT=0x%X\n", reclength);
  if (1 != fread(&loadaddress, sizeof loadaddress, 1, in))
    pexit("fread");
  printf("LOADADDR=0x%X\n",loadaddress);

  checksum_calc = reclength + loadaddress;

  /* copy data, calculate crc32 */
  while (compsize < reclength) {
    if (1 != fread(&buf, sizeof buf, 1, in))
      pexit("fread");
    compsize++;
    if (1 != fwrite(&buf, sizeof buf, 1, out))
      pexit("fwrite");
    checksum_calc += buf;
  }

  checksum_calc = ~checksum_calc + 1;
  printf("CHECKSUM_CALC=0x%X\n", checksum_calc);

  if (1 != fread(&checksum, sizeof checksum, 1, in))
    pexit("fread");
  printf("CHECKSUM=0x%X\n", checksum);

  if (1 != fread(&zero, sizeof zero, 1, in))
    pexit("fread");
  printf("ZERO=0x%X\n", zero);
  if (1 != fread(&entry, sizeof entry, 1, in))
    pexit("fread");
  printf("ENTRY=0x%X\n", entry);

  fclose(in);

  if (fclose(out))
    pexit("fclose");

  return 0;

/*
        bzimage2eva
        Copyright (C) 2017  Sebastian Frei <[email protected]>
        derived from

    lzma2eva - convert lzma-compressed file to AVM EVA bootloader format
    Copyright (C) 2007  Enrik Berkhan <[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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
*/

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

void
usage(void)
{
  fprintf(stderr, "usage: bzimage2eva <loadadddr> <entry> <bzimagefile> <evafile>\n");
  exit(1);
}

void
pexit(const char *msg)
{
  perror(msg);
  exit(1);
}

int
main(int argc, char *argv[])
{

  const char *infile, *outfile;
  FILE *in, *out;
  uint8_t buf[4096];
  size_t elems;

  uint32_t magic = 0xfeed8112L;
  uint32_t reclength = 0;
  fpos_t reclengthpos;
  uint32_t loadaddress = 0;
  uint32_t checksum = 0;

  uint32_t compsize = 0;

  uint32_t zero = 0;
  uint32_t entry = 0;

  if (argc != 5)
    usage();

  /* "parse" command line */
  loadaddress = strtoul(argv[1], 0, 0);
  entry = strtoul(argv[2], 0, 0);
  infile = argv[3];
  outfile = argv[4];

  in = fopen(infile, "rb");
  if (!in)
    pexit("fopen");
  out = fopen(outfile, "w+b");
  if (!out)
    pexit("fopen");

  /* write EVA header */
  if (1 != fwrite(&magic, sizeof magic, 1, out))
    pexit("fwrite");
  if (fgetpos(out, &reclengthpos))
    pexit("fgetpos");
  if (1 != fwrite(&reclength, sizeof reclength, 1, out))
    pexit("fwrite");
  if (1 != fwrite(&loadaddress, sizeof loadaddress, 1, out))
    pexit("fwrite");

  /* copy compressed data */
  while (0 < (elems = fread(&buf, sizeof buf[0], sizeof buf, in))) {
    compsize += elems;
    if (elems != fwrite(&buf, sizeof buf[0], elems, out))
      pexit("fwrite");
  }
  if (ferror(in))
    pexit("fread");
  fclose(in);

  /* re-write record length */
  reclength = compsize;
  if (fsetpos(out, &reclengthpos))
    pexit("fsetpos");
  if (1 != fwrite(&reclength, sizeof reclength, 1, out))
    pexit("fwrite");

  /* calculate record checksum */
  checksum += reclength;
  checksum += loadaddress;
  if (fseek(out, 4, SEEK_CUR)) // skip loadaddress
    pexit("fseek");
  while (0 < (elems = fread(&buf, sizeof buf[0], sizeof buf, out))) {
    size_t i;
    for (i = 0; i < elems; ++i)
      checksum += buf[i];
  }
  if (ferror(out))
    pexit("fread");
  if (fseek(out, 0, SEEK_CUR))
    pexit("fseek");

  checksum = ~checksum + 1;
  if (1 != fwrite(&checksum, sizeof checksum, 1, out))
    pexit("fwrite");

  /* write entry record */
  if (1 != fwrite(&zero, sizeof zero, 1, out))
    pexit("fwrite");
  if (1 != fwrite(&entry, sizeof entry, 1, out))
    pexit("fwrite");

  if (fclose(out))
    pexit("fclose");

  return 0;
}