/* 
 [ROM用] make_sdtad_table.exe -dir test-tad -odir [dir] -var MAKEROM_TAD_ROMFILES -fdir tads -mk Makefile.inc
 [SD用] make_sdtad_table.exe -sd -dir test-tad -odir [dir] -fdir sdtads

 table_file.txt 名前固定

 makesdtd.exe -indir [inputdir] -odir sdtads
 makesdtd.exe [-c] -indir test-tad -odir sdtads

 openssl genrsa -out tad1024china.der 1024 -outform DER

 rsa_keysrcgen.exe -in tad1024china.der

*/


/*
  #include <unistd.h>
  char *getcwd(char *buf, size_t size);
  char *getwd(char *buf);
  char *get_current_dir_name(void);
*/


#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h> 
#include <unistd.h> 

#include "my_sign.h"

typedef unsigned char   u8;
typedef unsigned short u16;
typedef unsigned long  u32;
typedef unsigned long long u64;
typedef int BOOL;

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif


/* グローバルデータ */

#define MAX_TITLE_IDS 2048
static int num_of_title_ids = 0;
static u32 title_id_hi_array[MAX_TITLE_IDS];
static u32 title_id_lo_array[MAX_TITLE_IDS];
static u16 title_ver_array[MAX_TITLE_IDS];
static u16 title_gid_array[MAX_TITLE_IDS];
static char title_rom_file_full_path[MAX_TITLE_IDS][256];
static char key_file_path[256];


/* tadのデータは基本的にビッグエンディアン */

typedef struct {
  u32 hdrSize;
  u16 tadType;
  u16 tadVersion;
  u32 certSize;
  u32 crlSize;
  u32 ticketSize;
  u32 tmdSize;
  u32 contentSize;
  u32 metaSize;    

  u32 certOffset;
  u32 crlOffset;
  u32 ticketOffset;
  u32 tmdOffset;
  u32 contentOffset;
  u32 metaOffset;
  u32 fileSize;
} TAD_INFO;

typedef struct NAMiTADHeader
{
  u32 hdrSize;        // Size of TADHeader1 96
  u8  tadType[2];
  u16 tadVersion;		// TAD_VERSION_1
  u32 certSize;
  u32 crlSize;
  u32 ticketSize;
  u32 tmdSize;
  u32 contentSize;
  u32 metaSize;
} NAMiTADHeader;

typedef u64 OSTitleId;
typedef OSTitleId NAMTitleId;

typedef struct NAMTitleInfo
{
  NAMTitleId  titleId;
  u16 companyCode;
  u16 version;
  u32 publicSaveSize;
  u32 privateSaveSize;
  u32 blockSize;
} NAMTitleInfo;

typedef struct NAMTadInfo
{
    NAMTitleInfo titleInfo;
    u32     fileSize;
} NAMTadInfo;


#define ES_APP_ENC_HANDLE       6

#define ES_ROOT_NAME            "Root"
#define ES_CA_PREFIX            "CA"
#define ES_XS_PREFIX            "XS"
#define ES_MS_PREFIX            "MS"
#define ES_CP_PREFIX            "CP"
#define ES_APP_CERT_PREFIX      "AP"

#define ES_BUF_SIZE             256

typedef u32  ESId;                 /* 32-bit device identity */
typedef u32  ESContentId;          /* 32-bit content identity */
typedef u64  ESTitleId;            /* 64-bit title identity */
typedef u64  ESTicketId;           /* 64-bit ticket id */
typedef u8   ESVersion;            /* 8-bit data structure version */
typedef u16  ESTitleVersion;       /* 16-bit title version */
typedef ESTitleId ESSysVersion;    /* 64-bit system software version */
typedef u32  ESTitleType;          /* title type */
typedef u16  ESContentType;        /* content type */
typedef u8   ESTmdReserved[62];    /* reserved field in TMD structure */
typedef u8   ESTicketReserved[47]; /* reserved field in eTicket structure */
typedef u8   ESSysAccessMask[2];   /* 16 bit cidx Mask to indicate which 

                                      content can be accessed by sys app */
#if !defined(__ES_INTERNAL__)
/* IOSC types */
typedef u8   IOSCAesKey[16];
typedef u8   IOSCHash[20];
typedef u8   IOSCName[64];
typedef u8   IOSCSigDummy[60];
typedef u8   IOSCCertPad[52];
typedef u8   IOSCEccCertPad[4];
typedef u8   IOSCRsaSig2048[256];
typedef enum {
    IOSC_SIG_RSA4096 = 0x00010000,  /* RSA 4096 bit signature */
    IOSC_SIG_RSA2048,  /* RSA 2048 bit signature */
    IOSC_SIG_ECC       /* ECC signature 512 bits*/
} IOSCCertSigType;
typedef enum {
    IOSC_PUBKEY_RSA4096,  /* RSA 4096 bit key */
    IOSC_PUBKEY_RSA2048,  /* RSA 2048 bit key */
    IOSC_PUBKEY_ECC       /* ECC pub key 512 bits*/
} IOSCCertPubKeyType;
typedef u8   IOSCEccSig[60];
typedef u8   IOSCEccPublicKey[60];

typedef struct {
    IOSCCertSigType sigType;
    IOSCRsaSig2048  sig;
    IOSCSigDummy    dummy;
    IOSCName        issuer;
} IOSCSigRsa2048;

typedef u8   IOSCEccPrivatePad[2];
typedef u8   IOSCEccPublicPad[4];
typedef struct {
    IOSCCertSigType  sigType;
    IOSCEccSig       sig;
    IOSCEccPublicPad eccPad;
    IOSCSigDummy     dummy;
    IOSCName         issuer;
} IOSCSigEcc;

typedef u8   IOSCDeviceId[64];
typedef u8   IOSCServerId[64];
typedef struct {
    IOSCCertPubKeyType pubKeyType;
    union {
        IOSCServerId serverId;
        IOSCDeviceId deviceId;
    } name;
    u32 date;
} IOSCCertHeader;
typedef struct {
    IOSCSigEcc          sig;        /* ECC signature struct */
    IOSCCertHeader      head;
    IOSCEccPublicKey    pubKey;     /* 60 byte ECC public key */
    IOSCEccPublicPad    eccPad;
    IOSCCertPad         pad;
    IOSCEccCertPad      pad2;
} IOSCEccEccCert;
#endif

#define ES_TMD_VERSION             0
#define ES_TICKET_VERSION          0

/* TMD View */
#define ES_MAX_CONTENT             512

#define ES_TITLE_TYPE_NC_TITLE     0         /* NC title */
#define ES_TITLE_TYPE_NG_TITLE     1         /* NG title */
#define ES_TITLE_TYPE_DS_TITLE     2         /* DS title for NC */
#define ES_TITLE_TYPE_STREAM       4         /* stream title */
#define ES_TITLE_TYPE_DATA         8         /* data title */
#define ES_CONTENT_TYPE_SHARED     (1<<15)   /* shared content */
#define ES_CONTENT_TYPE_OPTIONAL   (1<<14)   /* optional content */
#define ES_CONTENT_TYPE_DISC       (1<< 1)   /* disc content */
#define ES_CONTENT_TYPE_NC_EXE     0         /* NC merged elf */
#define ES_CONTENT_TYPE_NG_EXE     1         /* NG content */

#define ES_LICENSE_MASK      0x0f /*  allow 16 licensing types */
#define ES_LICENSE_PERMANENT 0x00 /* e.g.,  regular game with permanent rights */
#define ES_LICENSE_DEMO      0x01 /* e.g.,  demo game with permanent rights */
#define ES_LICENSE_TRIAL     0x02 /* e.g.,  regular game with limited rights */
#define ES_LICENSE_RENTAL    0x03 /* TBD */
#define ES_LICENSE_SUBSCRIPTION 0x04 /* TBD */    
#define ES_LICENSE_GIFT_MASK 0x80 /* this is a gift */

/* TMD */
typedef struct {
    ESContentId    cid;    /* 32 bit content id */
    u16            index;  /* content index, unique per title */
    ESContentType  type;   /* content type*/
    u64            size;   /* unencrypted content size in bytes */
    IOSCHash       hash;   /* 160-bit SHA1 hash of the content */
} ESContentMeta;

typedef struct {
    ESVersion      version;  /* TMD version number */
    ESVersion      caCrlVersion;  /* CA CRL version number */
    ESVersion      signerCrlVersion; /* signer CRL version number */
    ESSysVersion   sysVersion;  /* required system software version number */

    ESTitleId      titleId;      /* 64 bit title id */
    ESTitleType    type;         /* 32 bit title type */
    u16            groupId;
    ESTmdReserved  reserved;     /* 62 bytes reserved info for Nintendo */
    u32            accessRights; /* title's access rights to use 
                                    system resources */
    ESTitleVersion titleVersion; /* 16 bit title version */
    u16            numContents;  /* number of contents per title */
    u16            bootIndex;    /* boot content index */
} ESTitleMetaHeader;

typedef struct {
    IOSCSigRsa2048     sig;      /* RSA 2048bit sign of all the data in 
                                    the TMD file */
    ESTitleMetaHeader  head;
    ESContentMeta      contents[ES_MAX_CONTENT];
} ESTitleMeta;

/* TMD View */
typedef struct {
    ESVersion        version;           /* TMD data structure version */
    ESSysVersion     sysVersion;        /* required system software 
                                           version number */
    ESTitleId        titleId;           /* 64 bit title id */
    ESTitleType      type;              /* 32 bit title type */
    u16              groupId;
    ESTmdReserved    reserved;          /* 62 bytes reserved info */
    ESTitleVersion   titleVersion;      /* 16 bit title version */
    u16              numContents;       /* number of contents in the title */
} ESTmdViewHeader;

typedef struct {
    ESContentId      cid;               /* 32 bit content id */
    u16              index;             /* 16 bit content index */
    ESContentType    type;              /* 16 bit content type */
    u64              size;              /* 64 bit content size */
} ESCmdView;

typedef struct {
    ESTmdViewHeader head;
    ESCmdView       contents[ES_MAX_CONTENT];
} ESTmdView;



typedef struct NAMiTadParams
{
    u32 cert;
    u32 crl;
    u32 ticket;
    u32 tmd;
    u32 content;
    u32 meta;
}
NAMiTadParams;

//---- tad 構成情報
typedef struct NAMiTadInfo
{
    NAMiTadParams sizes;        // 各領域のサイズ
    NAMiTadParams offsets;      // ファイル先頭から各領域へのオフセット
}
NAMiTadInfo;

#if 0
static my_NAM_ReadTadInfoWithFile(FILE *fp, TAD_INFO *tad_info)
{
 NAMiTadInfo tadInfo;
 ESTitleMeta tmd;
 int result;

 result = my_sign_ReadTadHeader(fp, &tadInfo);

 // TMD を読む
 fread(&tmd, tmd-size, fp);
 result = NAMi_Load_sign( fp, (void*)tmd, tadInfo.sizes.tmd,
			  tadInfo.offsets.tmd,


 NAMi_CopyTmdReservedInfo(&pInfo->titleInfo, &pTmd->head.reserved);
 pInfo->titleInfo.titleId            = NAMi_EndianU64(pTmd->head.titleId);
 pInfo->titleInfo.companyCode        = NAMi_EndianU16(pTmd->head.groupId);
 pInfo->titleInfo.version            = NAMi_EndianU16(pTmd->head.titleVersion);
 pInfo->titleInfo.blockSize          = my_NAMi_CalcTitleBlocksFromTmd(pTmd);
 pInfo->fileSize                     = my_sign_FS_GetLength(pTadFile);
 
 NAMi_Free(pTmd);

}
#endif

#if 0
static void test(void)
{
  NAMiTadInfo* pInfo;
  // ESTitleMeta tmd;
#if 0
  typedef struct {
    ESVersion      version;  /* TMD version number */
    ESVersion      caCrlVersion;  /* CA CRL version number */
    ESVersion      signerCrlVersion; /* signer CRL version number */
    ESSysVersion   sysVersion;  /* required system software version number */
    
    ESTitleId      titleId;      // 8 
    ESTitleType    type;         // 4
    u16            groupId;      // 2
    ESTmdReserved  reserved;     /* 62 bytes reserved info for Nintendo */
    u32            accessRights; /* title's access rights to use 
                                    system resources */
    ESTitleVersion titleVersion; /* 16 bit title version */
    u16            numContents;  /* number of contents per title */
    u16            bootIndex;    /* boot content index */
  } ESTitleMetaHeader;
#endif

  printf("TMD head offset = %d 0x%04x\n", offsetof(ESTitleMeta, head), offsetof(ESTitleMeta, head));
  printf("ESTitleMetaHeader titleId offset = %d 0x%04x\n", offsetof(ESTitleMetaHeader ,titleId ), offsetof(ESTitleMetaHeader ,titleId));
  
  printf("ESTitleMetaHeader titleVersion offset = %d 0x%04x\n", offsetof(ESTitleMetaHeader ,titleVersion ), offsetof(ESTitleMetaHeader ,titleVersion));
  
  
  printf("ESTitleMetaHeader groupId offset = %d 0x%04x\n", offsetof(ESTitleMetaHeader ,groupId ), offsetof(ESTitleMetaHeader ,groupId));
  
  printf("ESTitleMetaHeader numContents offset = %d 0x%04x\n", offsetof(ESTitleMetaHeader ,numContents ), offsetof(ESTitleMetaHeader ,numContents));
  
  
  
  printf("NAMiTADHeader = %d 0x%04x\n",sizeof(NAMiTADHeader),sizeof(NAMiTADHeader));
  printf("ESTmdView = %d 0x%04x\n",sizeof(ESTmdView),sizeof(ESTmdView));
  printf("ESTmdViewHeader = %d 0x%04x\n",sizeof(ESTmdViewHeader),sizeof(ESTmdViewHeader));
  printf("ESCmdView = %d 0x%04x\n",sizeof(ESCmdView),sizeof(ESCmdView));
#if 0
  
  printf(" = %d 0x%04x\n",sizeof(),sizeof());
  printf(" = %d 0x%04x\n",sizeof(),sizeof());
  printf(" = %d 0x%04x\n",sizeof(),sizeof());
  printf(" = %d 0x%04x\n",sizeof(),sizeof());
  printf(" = %d 0x%04x\n",sizeof(),sizeof());
#endif
  
}
#endif
 
 




 




static BOOL debug_print_flag = FALSE;


static u32 reverseEndian4( const u32 v )
{
  u32 ret = (v<<24) | ((v<<8) & 0x00FF0000) | ((v>>8) & 0x0000FF00) | (v>>24);
  return ret;
}

static u16 reverseEndian2( const u16 v )
{
  u16 ret = (v<<8) | (v>>8);
  return ret;
}

static u32 roundUp4( const u32 v, const u32 align )
{
	u32 r = ((v + align - 1) / align) * align;
	return r;
}

#if 0
/* unused */
static u16 roundUp2( const u16 v, const u16 align )
{
	u16 r = ((v + align - 1) / align) * align;
	return r;
}
#endif

static u16 read2bytes(FILE *fp)
{
  u16 buf;
  if( 2 != fread(&buf,1,2,fp) ) {
    fprintf(stderr, "Error: %s %s %d\n",__FILE__,__FUNCTION__,__LINE__);
    exit(-1);
  }
  return buf;
} 

static u32 read4bytes(FILE *fp)
{
  u32 buf;
  if( 4 != fread(&buf,1,4,fp) ) {
    fprintf(stderr, "Error: %s %s %d\n",__FILE__,__FUNCTION__,__LINE__);
    exit(-1);
  }
  return buf;
} 


static BOOL read_tad_info(FILE *fp, TAD_INFO *tad_info)
{

  tad_info->hdrSize     = reverseEndian4( read4bytes(fp) );	// 基本的にビッグエンディアン
  tad_info->tadType     = reverseEndian2( read2bytes(fp) );
  tad_info->tadVersion  = reverseEndian2( read2bytes(fp) );
  tad_info->certSize    = reverseEndian4( read4bytes(fp) );
  tad_info->crlSize     = reverseEndian4( read4bytes(fp) );
  tad_info->ticketSize   = reverseEndian4( read4bytes(fp) );
  tad_info->tmdSize      = reverseEndian4( read4bytes(fp) );
  tad_info->contentSize = reverseEndian4( read4bytes(fp) );
  tad_info->metaSize    = reverseEndian4( read4bytes(fp) );

  if( tad_info->hdrSize != 32) {
    return FALSE;
  }

  if( debug_print_flag ) {
    printf( "hdrSize     %d\n", (int)tad_info->hdrSize );
    printf( "tadType     %c%c\n", tad_info->tadType>>8, tad_info->tadType&0xFF );
    printf( "tadVersion  %d\n", (int)tad_info->tadVersion );
    printf( "certSize    %d\n", (int)tad_info->certSize );
    printf( "crlSize     %d\n", (int)tad_info->crlSize );
    printf( "ticketSize  %d\n", (int)tad_info->ticketSize );
    printf( "tmdSize     %d\n", (int)tad_info->tmdSize );
    printf( "contentSize %d\n", (int)tad_info->contentSize );
    printf( "metaSize    %d\n", (int)tad_info->metaSize );
  }


  tad_info->certOffset 		= roundUp4( tad_info->hdrSize , 64 );
  tad_info->crlOffset  		= roundUp4( tad_info->certOffset 	 + tad_info->certSize , 64 );
  tad_info->ticketOffset 	= roundUp4( tad_info->crlOffset 	 + tad_info->crlSize , 64 );
  tad_info->tmdOffset  		= roundUp4( tad_info->ticketOffset + tad_info->ticketSize , 64 );
  tad_info->contentOffset	= roundUp4( tad_info->tmdOffset 	 + tad_info->tmdSize , 64 );
  tad_info->metaOffset 		= roundUp4( tad_info->contentOffset+ tad_info->contentSize , 64 );
  tad_info->fileSize		= roundUp4( tad_info->metaOffset 	 + tad_info->metaSize , 64 );

  return TRUE;
}


static u8 *alloc_and_read(FILE *fp, int offset, int size)
{
  u8 *buf;
  if( fp == NULL || size < 1 ) {
    fprintf(stderr, "Error %s open file\n",__FUNCTION__);
    return NULL;
  }

  buf = malloc(size);
  if( buf == NULL ) {
    fprintf(stderr, "Error %s memory allocate \n",__FUNCTION__);
    return NULL;
  }
  
  if( -1 == fseek( fp, offset, SEEK_SET ) ) {
    fprintf(stderr, "Error: %s %s %d fseek offset=%d\n",__FILE__,__FUNCTION__,__LINE__,offset);
    return NULL;
  }
  if( size != fread(buf,1,size,fp) ) {
    fprintf(stderr, "Error: %s %s %d fread size=%d\n",__FILE__,__FUNCTION__,__LINE__,size);
    return NULL;
  }    
  return buf;
}

#if 0
/* unused */
static BOOL saveFile(char *name, char *buf, int size)
{
  FILE *fp;
  fp = fopen(name, "wb");
  if( fp == NULL ) {
    fprintf(stderr, "Error %s %d file open\n",__FUNCTION__,__LINE__);
    return FALSE;
  }
  if( fwrite(buf, 1, size, fp) != size ) {
    fprintf(stderr, "Error %s %d file write\n",__FUNCTION__,__LINE__);
    return FALSE;
  } 
  fclose( fp );
  return TRUE;
}
#endif

#if 0
static void print_gamecode(u32 tid_lo)
{
  char gamecode[5];

  char *str;
  str = gamecode;
  *str++ = (char)((tid_lo >> 24) & 0xff);
  *str++ = (char)((tid_lo >> 16) & 0xff);
  *str++ = (char)((tid_lo >> 8) & 0xff);
  *str++ = (char)(tid_lo  & 0xff);
  *str  = '\0';
  printf( "%s", gamecode );
}
#endif


#if 0
static write_tad_table_form(FILE *fp, u32 tid_hi, u32 tid_lo, char *filename)
{
  fprintf(fp, "0x%08x%08x, %d , %d , rom:/tads/%s\n",tid_hi, tid_lo, 0 , 0 , filename);
}
#endif

static BOOL read_file_and_print_titleid( char *path , char *d_name, FILE *fp_out, FILE *fp_mk)
{
  FILE *fp_in = NULL;
  TAD_INFO tad_info;
  u8 *tmd = NULL;
  u32 titleid_hi = 0;
  u32 titleid_lo = 0;
  u16 t_ver;
  u16 gid;
  int i;
  BOOL ret_flag = TRUE;


  fp_in = fopen(path,"rb");	/* fseek効かすため */
  if( fp_in == NULL ) {
    fprintf(stderr, "error: file open %s\n",path);
    ret_flag = FALSE;
    goto end_file; 
 }

  /* TADファイルかどうかチェック */
  if( FALSE == read_tad_info(fp_in, &tad_info) ) {
    //    fprintf(stderr, "error:%s %d\n",__FUNCTION__,__LINE__);
    ret_flag = FALSE;
    goto end_file;
  }


  fseek( fp_in, 0, SEEK_END );
  if( tad_info.fileSize != ftell( fp_in ) ) {
    printf( "file size is not expected size(=%d)", (int)tad_info.fileSize );
    ret_flag = FALSE;
    goto end_file;
  }
  
  tmd = alloc_and_read( fp_in, tad_info.tmdOffset, tad_info.tmdSize );


  titleid_hi = reverseEndian4( *((u32 *)( tmd + 0x18C )) );
  titleid_lo = reverseEndian4( *((u32 *)( tmd + 0x18C + 4 )) );

  t_ver = reverseEndian2( *((u16 *)( tmd + 0x1DC )) ); 
  gid  = reverseEndian2( *((u16 *)( tmd + 0x198)) ); 
#if 0
  printf("0x%08x%08x ver=0x%04x gid=0x%04x\n",titleid_hi,  titleid_lo, 
	 t_ver,groupId);
#endif

  if( debug_print_flag ) {
    printf("inputfile = %s\n", path);
  }


  /* ここでタイトルＩＤの重複チェックする */
  for( i = 0 ; i < num_of_title_ids ; i++ ) {
    if( (title_id_hi_array[i] == titleid_hi) && (title_id_lo_array[i] == titleid_lo) ) {
      if( title_ver_array[i] == t_ver ) {
	/* バージョンも含めて重複してる！ */
	fprintf(stderr, "Error: title exists redundantly\n");
      }
      else {
	/* バージョン違いだけど重複してる */
	fprintf(stderr, "Warning: title exists in different versions\n");
      }

      fprintf(stderr, "  0x%08x%08x, 0x%04x , 0x%04x  %s\n", 
	      (int)title_id_hi_array[i], (int)title_id_lo_array[i], 
	      title_ver_array[i], title_gid_array[i], title_rom_file_full_path[i] );
      fprintf(stderr, "  0x%08x%08x, 0x%04x , 0x%04x  %s\n", (int)titleid_hi,  (int)titleid_lo, t_ver , gid , path);
    }
  }


  title_id_hi_array[ num_of_title_ids ] = titleid_hi;
  title_id_lo_array[ num_of_title_ids ] = titleid_lo;
  title_ver_array[ num_of_title_ids ] = t_ver;
  title_gid_array[ num_of_title_ids ] = gid;
  strcpy( title_rom_file_full_path[num_of_title_ids], path);

  num_of_title_ids++;

  if( fp_out ) {
    fprintf(fp_out, "0x%08x%08x, 0x%04x , 0x%04x , sdmc:/%s,\n", 
	    (int)titleid_hi,  (int)titleid_lo, t_ver , gid , d_name);
    if( fp_mk ) {
      fprintf(fp_mk, "\t\t%s \\\n", d_name);
    }
  }
  else {
    printf("0x%08x%08x, 0x%04x , 0x%04x , sdmc:/%s,\n",
	   (int)titleid_hi,  (int)titleid_lo, t_ver , gid , d_name);
  }
  
 end_file:
  if(tmd) {
    free(tmd);
  }
  
  if( fp_in ) {
    fclose(fp_in);
  }

  return ret_flag;
}

int main(int argc, char **argv)
{
  int i;
  FILE *fp_in = NULL;
  FILE *fp_out = NULL;
  FILE *fp_mk = NULL;
  char *infile = NULL;
  char *outfile = NULL;

  char *outdir_name = NULL;
  char *indir_name = NULL;

  BOOL read_file_flag = FALSE;
  BOOL write_file_flag = FALSE;
  BOOL write_dir_flag = FALSE;
  BOOL dir_read_flag = FALSE;
  BOOL china_flag = FALSE;

  char *prog;
  int badops = 0;
  u8 *ticket = NULL;
  u8 *tmd = NULL;
  u8 *content = NULL;
  //  u64 titleid = 0;
#if 0
  TAD_INFO tad_info;
  u32 titleid_hi = 0;
  u32 titleid_lo = 0;
  u16 groupid = 0;
#endif
  DIR *indir;
  DIR *outdir;
  struct dirent *dr;
  struct stat st;
  char *full_path;
  char rom_file_full_path[256];
  BOOL func_ret_flag;
  char out_file_full_path[256];
  char table_file_full_path[256];
  char en_table_file_full_path[256];
  int len;
  int pos;


  prog=argv[0];
  argc--;
  argv++;


  
  while (argc >= 1) {
    if (strcmp(*argv,"-indir") == 0  && !dir_read_flag ) {
      if (--argc < 1) {
	goto bad;
      }
      indir_name = *++argv;
      dir_read_flag = TRUE;
    }
    else if (strcmp(*argv,"-odir") == 0 && !write_dir_flag ) {
      if (--argc < 1) {
	goto bad;
      }
      outdir_name = *++argv;
      write_dir_flag = TRUE;
    }
    else if (strcmp(*argv,"-d") == 0 ) {
      debug_print_flag = TRUE;
    }
    else if (strcmp(*argv,"-c") == 0 ) {
      china_flag = TRUE;
    }
    else if ( !read_file_flag ) {
      infile = *argv;
      read_file_flag = TRUE;
    }
    else {
      goto bad;
    }
    argc--;
    argv++;
  }



  if (badops) {
  bad:
    fprintf(stderr, "%s [-c] -indir dirname -odir dirname\n",prog);
    goto end;
  }


  //  printf("d = %s\n", prog);
  //  strcpy(key_file_path, ".\\");
  strcat(key_file_path, prog);
  len = strlen(key_file_path);
  for( pos = len - 1 ; pos > 0 ; pos--) {
    if( key_file_path[pos] == '\\' ) {
      if( china_flag == TRUE ) {
	strcpy( &(key_file_path[pos]), "\\tad1024china.der");
      }
      else {
	strcpy( &(key_file_path[pos]), "\\tad1024.der");
      }
      break;
    }
  }
  printf("key_file_path = %s\n",key_file_path );
    


    if( debug_print_flag ) {
      printf("dir name = %s\n", indir_name);
    }
    indir = opendir(indir_name);
    if( indir == NULL ) {
      fprintf(stderr, "error: dir open %s\n",indir_name);
      goto end;
    }


    if( write_dir_flag ) {
      outdir = opendir(outdir_name);
      if( outdir == NULL ) {
	//	fprintf(stderr, "error: dir open %s\n",indir_name);
	/*
	  EACCES 
	  アクセス権限がない。 
	  EBADF 
	  fd が読み出し用にオープンされた、有効なファイルディスクリプタではない。 
	  EMFILE 
	  プロセスが使用中のファイルディスクリプタが多すぎる。 
	  ENFILE 
	  システムでオープンされているファイルが多すぎる。 
	  ENOENT 
	  ディレクトリが存在しないか、または name が空文字列である。 
	  ENOMEM 
	  命令を実行するのに充分なメモリがない。 
	  ENOTDIR 
	  name はディレクトリではない。 
	*/
	if( -1 ==  mkdir(outdir_name) ) {
	  fprintf(stderr, "error: mkdir %s\n",indir_name);
	  goto end;
	}

      }
      else {
	closedir(outdir);
      }



      strcpy(table_file_full_path, outdir_name);
      strcat(table_file_full_path, "/table_file.txt");
      outfile = table_file_full_path;

      strcpy(en_table_file_full_path, outdir_name);
      strcat(en_table_file_full_path, "/en_sdtad_table.txt");

      fp_out = fopen(outfile,"wb");	/* fseek効かすため */
      if( fp_out == NULL ) {
	fprintf(stderr, "error: file open %s\n",outfile);
	goto end;
      }
      write_file_flag = TRUE;
    }

    

    if( 0 != cryptopc_init( key_file_path ) ) {
      fprintf(stderr, "error: cryptopc\n");
      goto end;
    }


    /* チェック用のテーブル初期化(いらんけど) */
    num_of_title_ids = 0;
    for( i = 0 ; i < MAX_TITLE_IDS ; i++ ) {
      title_id_hi_array[i] = 0;
      title_id_lo_array[i] = 0;
      title_ver_array[i] = 0;
      title_gid_array[i] = 0;
      title_rom_file_full_path[i][0] = 0;
    }
    
    /* ディレクトリ中のTADファイルをリストにして表示する。 */
    while( (dr = readdir(indir)) != NULL ) {
      if (!strcmp(dr->d_name, ".") || !strcmp(dr->d_name, "..")) {
	continue;
      }
	
      full_path = malloc( strlen(indir_name) + strlen(dr->d_name) + 2);
      strcpy(full_path, indir_name);
      strcat(full_path, "/");
      strcat(full_path, dr->d_name);

      // printf("%s\n", full_path);
      if ( stat(full_path, &st) != 0 ) {
	free( full_path);
	continue;
      }

      if (S_ISDIR(st.st_mode) == 1) {
	if( debug_print_flag ) {
	  printf("DIR  %s\n",  dr->d_name);
	}
      }
      else {
	if( debug_print_flag ) {
	  printf("FILE %s\n",  dr->d_name);
	}
	if( st.st_size >= 32 ) { 
	  //  strcpy( rom_file_full_path, file_dir);
	  //  strcat( rom_file_full_path, "/");
	  // strcat( rom_file_full_path, "en_");
	  strcpy( rom_file_full_path, "sdtads/en_");
	  strcat( rom_file_full_path, dr->d_name);
	  func_ret_flag = read_file_and_print_titleid( full_path ,rom_file_full_path, fp_out , fp_mk );

	  if( func_ret_flag == TRUE ) {
	    strcpy(out_file_full_path, outdir_name);
	    strcat(out_file_full_path, "/en_");
	    strcat(out_file_full_path, dr->d_name);
	    //	    printf("cryptopc tad1024.der %s %s\n",full_path, out_file_full_path);
	    putchar('.');
	    (void)cryptopc(full_path, out_file_full_path);
	    /* 
	       tadファイルだったのでテーブルファイルに登録された。
	       なので暗号化をついでにする。
	    */
	  }
	}
      }
      free( full_path);
    }
    putchar('\n');

    if( indir ) {
      (void)closedir( indir );
    }

    if( write_file_flag ) {
      if( fp_out ) {
	fclose(fp_out);
	fp_out = NULL;
      }
      /* table_file.txt も暗号化する */
      (void)cryptopc(table_file_full_path, en_table_file_full_path);
      // char en_table_file_full_path[256];
    }

 end:

    if( ticket ) {
      free(ticket);
    }
    if(tmd) {
      free(tmd);
    }
    if(content) {
      free(content);
    }
    if( fp_in ) {
      fclose(fp_in);
    }
    if( fp_out ) {
      fclose(fp_out);
    }

    if( fp_mk ) {
      fclose(fp_mk);
    }

    cryptopc_end();


  return 0;
}