/*
 *  +-------------------------------------------------------------------+
 *  | Copyright (c) 1995,2000 TriMedia Technologies Inc.                |
 *  |                                                                   |
 *  | This software  is furnished under a license  and may only be used |
 *  | and copied in accordance with the terms  and conditions of such a |
 *  | license  and with  the inclusion of this  copyright notice.  This |
 *  | software or any other copies of this software may not be provided |
 *  | or otherwise  made available  to any other person.  The ownership |
 *  | and title of this software is not transferred.                    |
 *  |                                                                   |
 *  | The information  in this software  is subject  to change  without |
 *  | any  prior notice  and should not be construed as a commitment by |
 *  | TriMedia Technologies.                                            |
 *  |                                                                   |
 *  | This  code  and  information  is  provided  "as is"  without  any |
 *  | warranty of any kind,  either expressed or implied, including but |
 *  | not limited  to the implied warranties  of merchantability and/or |
 *  | fitness for any particular purpose.                               |
 *  +-------------------------------------------------------------------+
 *
 *  Module name              : tmSEI.c    1.25
 *
 *  Module type              : IMPLEMENTATION
 *
 *  Title                    : Self Extracting Image
 *
 *  Last update              : 16:05:37 - 00/06/16
 *
 *  Description              : Usase zlib compression, Command line parser
 *                             and down loader    
 */
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#ifndef _WIN32
#include <unistd.h>
#include <dirent.h>
#else
#include <windows.h>
#endif

#include <TMDownLoader.h>
#include <tmhost.h>

/* if using the hp build */
#ifdef hpux
/* undefine Long and uLongf */   
#undef uLong
#undef uLongf
#undef Byte
#endif

#include "tsaCmdOpt.h"
#include <zlib.h>

#include "tmSEI_options.h"
  
tsaCmdOptOption_t	options[] = {
#define	_Eg_opts_impl
#undef	Def
#define	Def(name,o1,o2,typ,flags,dflt,descr)	\
  o1,o2,typ,flags,(void *)(dflt),descr,Null,
#include "tmSEI_options.h"
};

#ifndef O_BINARY
#define O_BINARY 0 /* not defined on Unix */
#endif

#ifdef _WIN32
#define SLASH "\\"
#else
#define SLASH "/"
#endif

#define UNIX_PATH_NAME_SEPARATOR '/'
#define WIN_PATH_NAME_SEPARATOR  '\\'

#define MAX_FILENAME 1024
#define BLOCKSIZE    0x800
#define TEMP_DIR     ".tmSEI.temp"
#define TEMP_BASE    "tmpackedimage"

#define TCS_BIN      TCSString SLASH "bin" SLASH 

#define	Nelts(vec)	(sizeof(vec) / sizeof((vec)[0]))

static const char *progname = NULL;

static char *out_name_temp = NULL;
static char *out_namet =NULL;
static char *out_nameh =NULL;
static char *shrinkflags;

static char buffer[MAX_FILENAME];
static char tcspath_buffer[MAX_FILENAME];
static char sei_ldflags[MAX_FILENAME];

static int fo = 0;
static int ft = 0;
static int fh = 0;

static int mem_start = 0;
static int mem_end   = 0;

static int sei_start = 0;
static int sei_end   = 0;


static char buf[BLOCKSIZE];

static unsigned int NumElements = 0;

/* options arguements intialised as per data
   struct in tmSEI_options.h */
static Bool  NoCompression;
static Bool  inmi;
static Bool  out;
static char* host;
static int   tm_freq;
static int                       mmio_base;
static char                     *output;
static TMDwnLdr_CachingSupport   cache_support;
static char                     *bigendian;
static Bool                      unshuffled;
static Bool                      verbose;
static char                     *cflags;
static char                     *ldflags;
static char                     *tcspath;
static char                     *cpath;

static char  *image_file;
static int   host_int;
static Bool  download_unshuffled;

static int text_len;
static int locked_text_len;
static int locked_text_base;

/* used for siumlator Memory image */
static int  lv_syscall;

/* Prototypes for hidden supported functions. */
void TMDwnLdr_set_unshuffled( TMDwnLdr_Object_Handle  handle );
void TMDwnLdr_get_text_positions( TMDwnLdr_Object_Handle handle, 
                                  Int *text_len, Int *locked_text_len, Int *locked_text_base);

/*--------------------------- helper functions -------------------------*/

static int
parse_number( char *repr, char terminator, char **next, int *result )
{
     char *nxt;

    *result= strtol( repr, &nxt, 0 );

    if(*result < 0){
       return False;
    }

    if( *nxt != terminator){
        printf("Wrong Numeric Format\n");
        return False;
    }

    if (next) { *next= nxt; }

    return True;
}


static int
copy( char *old, char *new){

   int src, dest ;
    int lv_read,lv_write,lv_ret,file_size;
    void *inmem;
    struct stat statBuf;
    
    src = open(old, O_RDONLY|O_BINARY);
    if (src == -1) {
        printf("Failed to open %s with error code %d\n", old, errno);
        return False;
    }

    /* get size of source file */
    lv_ret = fstat(src,&statBuf);
    if(lv_ret == -1) {
       printf("Failed to stat %s with error code %d\n", old, errno);
       close(src);
       return False;
    }
    
   file_size = statBuf.st_size;

   /* inmem is input memory */
   inmem = (void *)malloc(file_size);

   /* buffer will be output memory */
   if (inmem == NULL)
   {
      printf("out of memory\n");
      free(inmem);close(src);
      return False;
   }
   
   /* read the source into buf */
   lv_read= read  (src,  inmem, file_size);
   if(lv_read != file_size)
   {
       printf("read failure\n");
      free(inmem);close(src);
      return False;
   }

   close(src);

   dest = open(new,O_CREAT|O_WRONLY|O_BINARY,0x1FF);
   if (dest == -1) {
      printf("Failed to create %s with error code %d\n", new, errno);
      free(inmem);
      return False;
   }

   lv_write = write(dest, inmem, file_size);
   if(lv_write != file_size)
   {
       printf("write failure\n");
      free(inmem);   close(dest);
      return False;
   }

   free(inmem);
   close(dest);

   /* ensure that the file is readable */
   chmod(new,0x1FF);

   return file_size;
}

void 
rewrite_slashes( char *cmd )
{
#if defined(_WIN32)
	int i, len = strlen(cmd);

	for ( i = 0; i < len; i++ ) {
		if ( cmd[i] == UNIX_PATH_NAME_SEPARATOR )
			cmd[i] = WIN_PATH_NAME_SEPARATOR;
	}
#endif
}

#if	defined(_WIN32)
/* Windows implementation of Posix.1 directory handling calls:
 *	opendir(), readdir(), rewinddir(), closedir()
 * and also the unrelated system calls
 *	fsync(), sync().
 * These are implemented directly as system calls on SunOS and HP-UX
 * but not on Windows,
 * so this is Windows-specific code, required only for Windows.
 */

/* Directory entry. */
struct	dirent
{
	long	d_ino;
	long	d_namlen;
	char	d_name[MAX_PATH];
};

/* Directory. */
typedef	struct
{
	struct dirent	dirent;
	int		Win32EntryCount;
	HANDLE		Win32DirectoryHandle;
	WIN32_FIND_DATA	Win32FindData;
	char		Win32DirectoryName[1];
} DIR;

/* Open a directory. */
DIR *
opendir(char const *dirname)
{
	DIR	*dir;

	dir = (DIR *)malloc(sizeof(*dir) + strlen(dirname) + 3);
	if (dir == NULL) {
		/* No memory for DIR structure. */
		errno = ENOMEM;
		return NULL;
	}
	dir->Win32EntryCount = 0;
	sprintf(dir->Win32DirectoryName, "%s\\*", dirname);
	dir->Win32DirectoryHandle = FindFirstFile(dir->Win32DirectoryName,
						  &dir->Win32FindData);
	if (dir->Win32DirectoryHandle == INVALID_HANDLE_VALUE) {
		/* Not found, free and return failure. */
		free(dir);
		errno = ENOENT;
		return NULL;
	}
	return dir;	/* success */
}

/* Read the next entry from a directory. */
struct dirent *
readdir(DIR * dir)
{
	if (dir->Win32EntryCount == 0) {
		FindClose(dir->Win32DirectoryHandle);
		dir->Win32DirectoryHandle = FindFirstFile(dir->Win32DirectoryName,
							  &dir->Win32FindData);
		if (dir->Win32DirectoryHandle == INVALID_HANDLE_VALUE) {
			errno = EINVAL;
			return NULL;
		}
	} else if ((FindNextFile(dir->Win32DirectoryHandle,
				 &dir->Win32FindData) == 0) 
		&& (GetLastError() == ERROR_NO_MORE_FILES)) {
			return NULL;
	}
	dir->Win32EntryCount++;
	dir->dirent.d_ino = dir->Win32EntryCount;	/* this field is unneeded */
	dir->dirent.d_namlen = strlen(dir->Win32FindData.cFileName);
	strcpy(dir->dirent.d_name, dir->Win32FindData.cFileName);
	return &dir->dirent;
}

/* Rewind a directory. */
void
rewinddir(DIR *dir)
{
	dir->Win32EntryCount = 0;
}

/* Close a directory. */
int
closedir(DIR *dir)
{
	if (dir->Win32DirectoryHandle != INVALID_HANDLE_VALUE)
		FindClose(dir->Win32DirectoryHandle);
	free(dir);
	return 0;
}

/* File sync: a nop. */
int
fsync(int fildes)
{
	return 0;
}

/* Sync: a nop. */
int
sync(void)
{
	return 0;
}

#endif	/* defined(_WIN32) */


/*------------------------- conversion functions ----------------------*/

static
void ConvertOutToMI(char *outmem,int outsize,char *mimem,int *misize){

   Pointer     sdram_base = (Pointer)mem_start;
   UInt        sdram_length = mem_end - mem_start;

   TMDwnLdr_Object_Handle handle;
   TMDwnLdr_Status tmdl_ret;

   Int         alignment;
   
   /* load the executable object and create handle */
   if((tmdl_ret = TMDwnLdr_load_object_from_mem(outmem,outsize,Null,&handle)) != TMDwnLdr_OK) {
      fprintf(stdout, "Error TMDwnLdr_load_object_from_mem: %s\n", TMDwnLdr_get_last_error(tmdl_ret) );
      exit(-1);
   }
   
   /* if image should be unshuffled */
   if(unshuffled  == True || download_unshuffled == True){
      /* tell down loader to unshuffle image */
      TMDwnLdr_set_unshuffled(handle);
   }

   /* get the minimal image size */
   if((tmdl_ret = TMDwnLdr_get_image_size(handle, misize, &alignment)) != TMDwnLdr_OK) {
      fprintf(stdout, "Error TMDwnLdr_get_image_size: %s\n", TMDwnLdr_get_last_error(tmdl_ret) );
      exit(-1);
   }
   
   /* check if image size is too large */
   if(*misize > (Int) sdram_length)
      printf("Memory image 0x%x is larger than SDRAM 0x%x\n",*misize,(Int) sdram_length );
      
   if((Int) sdram_base % alignment != 0)
      printf("SDRAM Base 0x%x not aligned on a 64 byte boundary\n",sdram_base );

   /* resolve symbol - not used with nohost */
   if(host_int != tmNoHost){
      /* cheat a little bit */
      lv_syscall = mmio_base;
      
      if((tmdl_ret = TMDwnLdr_resolve_symbol(handle, "__syscall", (Int) lv_syscall)) != TMDwnLdr_OK) {
         fprintf(stdout, "Error TMDwnLdr_resolve_symbol: %s\n", TMDwnLdr_get_last_error(tmdl_ret) );
         exit(-1);
      }
   }

   /* relocate the executable */
   if((tmdl_ret = TMDwnLdr_relocate(handle, (tmHostType_t) host_int,
         (Address) mmio_base, (UInt) tm_freq, sdram_base,
         sdram_length,cache_support)) != TMDwnLdr_OK) {