/*
 * File Inspect and Broking End Resolver  -- fiber --
 *
 *       Copyright (C) 1997-2004  Shuichi Kitaguchi <kit@meadowy.org>
 *
 *
 * 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 versions 2, 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 fiber, see the file COPYING.  If not, write to the Free
 * Software Foundation Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*
 * HISTORY
 * -------
 *
 *    01 Feb, 1998 : Version 1.0.0 - first release.
 *    13 Jun, 1998 : Version 1.1.0 - if registry key is not found, write init values.
 *                                   add "-s" optoin.
 *                                   WriteRegistry bug fix.
 *                                   add "-o" option.
 *    23 Jun, 1998 : Version 1.1.1 - show options with "-l".
 *                                   remove copied file when "-s" mode.
 *                                   do not delete "foo.ext" when execute "fiber foo"
 *                                   and "foo.ext" exists.
 *    27 Jun, 1998 : Version 1.1.2 - add SEE_MASK_FLAG_DDEWAIT flag in
 *                                   ShellExecuteOpenSync.
 *    29 Jun, 1998 : Version 1.1.3 - use ShellExecuteEx if not sync mode.
 *    19 Jul, 1999 : Version 1.1.4 - add "-p" and "-n" option.
 *                                   "ExecuteUnknownExt=yes" is default.
 *    07 Aug, 1999 : Version 1.2.0 - add "-b" and "-d" option.
 *    05 Oct, 1999 : Version 1.2.1 - brush up English text.
 *    12 Jan, 2004 : Version 1.2.2 - convert path name to full path name before
 *                                   executing files.
 *                                 - eliminate "file:" scheme.
 *    18 Jan, 2004 : Version 1.2.3 - DO NOT eliminate "file:" scheme.
 */


#include <windows.h>
#include <shellapi.h>
#include <stdio.h>
#include <limits.h>
#include <mbstring.h>


#define FIBER_VERSION   "1.2.3"


/* constants */
#define FIBER_EXTNUM     64	/* default extension numbers */
#define FIBER_EXTLEN     8	/* extension length */
#define FIBER_OPTIONLEN  64	/* option length */
#define FIBER_IDENTLEN   32	/* ident length */
#define BUFLEN           4096	/* buffer */
#define FIBER_EXTLINELEN (FIBER_EXTLEN+FIBER_IDENTLEN+3) /* line len */

#define STATE_ERROR     0
#define STATE_INPUTFILE 1
#define STATE_ADDEXT    2

/* registry keys */
#define FIBER_SUBKEY                   "SOFTWARE\\GNU\\Fiber"
#define FIBER_SUBKEY_EXTNUM            "ExtNum"
#define FIBER_SUBKEY_EXECUTEUNKNOWNEXT "ExecuteUnknownExt"
#define FIBER_SUBKEY_EXECUTEURL        "ExecuteURL"
#define FIBER_SUBKEY_TRUSTEXT          "TrustExt"
#define FIBER_SUBKEY_OVERRIDEEXT       "OverrideExt"
#define FIBER_SUBKEY_EXTENSION         "Extension"


/* structures */
typedef struct tagEXTFILE {
  char  szExt[FIBER_EXTLEN+1];
  char  szIdent[FIBER_IDENTLEN+1];
  DWORD dwIdentLength;
  DWORD dwOffset;
} EXTFILE;


/* variables */
EXTFILE  *ef=NULL;
int      iExtNum=0;
int      iEfs=0;
BOOL     fExecuteUnknownExt;
BOOL     fExecuteURL;
BOOL     fTrustExt;
BOOL     fOverrideExt;

/* default ext values */
EXTFILE efInit[] = {
  {  "au", ".snd",4,0},
  { "wav", "WAVE",4,8},
  { "mid", "MThd",4,0},
  { "rcp", "RCM-PC98V2.0",12,0},
  { "mov", "moov",4,4},
  { "avi", "AVI",3,8},
  { "mpg", "\x00\x00\x01\xb3",4,0},
  { "jpg", "JFIF",4,134},
  { "jpg", "JFIF",4,6},
  { "bmp", "BM",2,0},
  { "gif", "GIF8",4,0},
  { "xpm", "XPM",3,3},
  { "tif", "MM",2,0},
  { "tif", "II",2,0},
  { "mki", "MAKI01",6,0},
  { "mag", "MAKI02",6,0},
  { "pic", "PIC",3,0},
  {  "pi", "Pi",2,0},
  {  "p2", "P2",2,0},
  { "png", "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a",8,0},
  { "pdf", "%PDF-",5,0},
  {  "ps", "%!",2,0},
  { "dvi", "\xf7\x02",2,0},
  { "zip", "PK",2,0},
  {  "gz", "\x1f\x8b",2,0},
  { "lzh", "SFX",3,0x48},
  { "lzh", "SFX",3,0x2e},
  { "lzh", "SFX",3,0x2a},
  { "lzh", "-lhd-",4,2},
  { "lzh", "-lh0-",4,2},
  { "lzh", "-lh1-",4,2},
  { "lzh", "-lh2-",4,2},
  { "lzh", "-lh3-",4,2},
  { "lzh", "-lh4-",4,2},
  { "lzh", "-lh5-",4,2},
  { "lzh", "-lh6-",4,2},
  { "lzh", "-lh7-",4,2},
  { "zoo", "ZOO",3,0},
  {    "",    "",0,0}
};



/* check file existing */
BOOL CheckFile( LPCSTR lpszFileName )
{
  HANDLE   hFile;

  hFile = CreateFile( lpszFileName,
		      GENERIC_READ,
		      FILE_SHARE_READ,
		      NULL,
		      OPEN_EXISTING,
		      0,
		      NULL );
  if ( hFile == INVALID_HANDLE_VALUE ){
    return ( FALSE );
  } else {
    CloseHandle( hFile );
    return ( TRUE );
  }
}


/* '/' -> '\' */
BOOL RevConvertPathSeparator( LPSTR szPathName )
{
  char *pt;

  while ( 1 ){
    pt = _mbsrchr( szPathName, '/' );
    if ( pt == NULL ) break;
    *pt = '\\';
  } /* while ( 1 ){ */

  return ( TRUE );
}


BOOL GetFileNameFromFullPath( LPCSTR szFullPath,
			      LPSTR  lpBuf,
			      DWORD  dwLength )
{
  char  *pt;
  DWORD dwLen;

  pt = _mbsrchr(szFullPath,'\\');
  if ( pt ){
    dwLen = strlen(pt) + 1;
    pt++;
  } else {
    dwLen = strlen(szFullPath) + 1;
    pt = (char*)szFullPath;
  } /* if ( pt ){ */
  if ( dwLen <= dwLength ){
    memcpy(lpBuf,pt,dwLen);
    return ( TRUE );
  } else {
    return ( FALSE );
  } /* if ( dwLen <= dwLength ){ */
}


BOOL BinaryToHexString( LPCSTR szString,
			DWORD  dwLen,
			LPSTR  lpBuf,
			DWORD  dwBufLen )
{
  DWORD i;
  char  szBuf[8];

  if ( dwBufLen < dwLen*4 ) return ( FALSE );
  lpBuf[0]=0;
  for ( i=0; i<dwLen; i++ ){
    sprintf(szBuf,"0x%02x",(BYTE)szString[i]);
    strcat(lpBuf,szBuf);
  }
  return ( TRUE );
}


/* string -> value */
BOOL CStringToValue( LPCSTR  szSrc,
		     LPDWORD lpdwDst )
{
  BOOL  ret;
  LPSTR pt;

  if ( szSrc[0] == '0' ){
    switch ( szSrc[1] ){
    case 'x':			/* hex */
      *lpdwDst = 0;
      pt = (LPSTR)&szSrc[2];
      while ( *pt ){
	if ( (*pt>='0') && (*pt<='9') ){
	  *lpdwDst = *lpdwDst*16 + *pt-'0';
	} else if ( (*pt>='A') && (*pt<='F') ){
	  *lpdwDst = *lpdwDst*16 + *pt-'A'+10;
	} else {
	  *lpdwDst = *lpdwDst*16 + *pt-'a'+10;
	}
	pt++;
      } /* while ( *pt ){ */
      ret = TRUE;
      break;
    case 'b':			/* bin */
      *lpdwDst = 0;
      pt = (LPSTR)&szSrc[2];
      while ( *pt ){
	*lpdwDst = *lpdwDst*2 + *pt-'0';
	pt++;
      }
      ret = TRUE;
      break;
    default:
      if ( (szSrc[1]>='0') && (szSrc[1]<='9') ){ /* oct */
	*lpdwDst = 0;
	pt = (LPSTR)&szSrc[1];
	while ( *pt ){
	  *lpdwDst = *lpdwDst*8 + *pt-'0';
	  pt++;
	}
	ret = TRUE;
      } else {			/* error */
	ret = FALSE;
      }
      break;
    }
  } else {
    /* dec */
    *lpdwDst = atol(szSrc);
    if ( *lpdwDst == 0 ){
      ret = FALSE;
    } else {
      ret = TRUE;
    }
  } /* if ( szSrc[0] == '0' ){ */
  return ( ret );
}

/* 0x**0x**... */
DWORD HexStringToBinary( LPCSTR szSrc,
			 LPSTR  szDst,
			 DWORD  dwLen )
{
  char  szBuf[FIBER_IDENTLEN+1];
  char  *spt,*dpt;
  DWORD dwRet;
  DWORD dwV;

  if ( strlen(szSrc) > FIBER_IDENTLEN ) return ( 0 );

  dwRet = 0;
  spt   = (LPSTR)szSrc;
  dpt   = szDst;
  while ( *spt ){
    memcpy(szBuf,spt,4);	/* xxx */
    szBuf[4] = 0;
    CStringToValue(szBuf,&dwV);
    *dpt++ = (char)dwV;
    dwRet++;
    spt += 4;
    if ( dwRet > dwLen ) break;
  } /* while ( *spt ){ */
  
  return ( dwRet );
}


BOOL SetEf( EXTFILE *ef, LPCSTR lpLine )
{
  char *pt,*ppt;
  BOOL ret=FALSE;

  if ( (pt=_mbschr(lpLine,'=')) != NULL ){
    *pt++ = (char)0;
    if ( strlen(lpLine) <= FIBER_EXTLINELEN ){
      strcpy(ef->szExt,lpLine);
      if ( (ppt=strchr(pt,',')) != NULL ){
	*ppt++ = (char)0;
	if ( ! CStringToValue(ppt,&ef->dwOffset) ){
	  printf("Error: illegal offset value.\n");
	  goto Exit;
	}
      } else {
	ef->dwOffset = 0;
      }	/* if ( (ppt=strchr(pt,',')) != NULL ){ */
      if ( strlen(pt) <= FIBER_IDENTLEN ){
	if ( *pt == '0' ){
	  ef->dwIdentLength =
	    HexStringToBinary(pt,ef->szIdent,sizeof(ef->szIdent));
	  } else {
	    strcpy(ef->szIdent,pt);
	    ef->dwIdentLength = strlen(ef->szIdent);
	  }
	ret = TRUE;
      } else {
	printf("Error: ident [%s] is too long.\n",pt);
      }	/* if ( strlen(pt) <= FIBER_IDENTLEN ){ */
    } else {
      printf("Error: ext [%s] is too long.\n",pt);
    } /* if ( strlen(lpLine) <= FIBER_EXTLINELEN ){ */
  } /* if ( (pt=_mbschr(lpLine,'=')) != NULL ){ */
 Exit:
  if ( ! ret )
    ef->szExt[0] = 0;
  return ( ret );
}


BOOL WriteRegistry( VOID )
{
  DWORD ret;
  HKEY  hKey;
  char  szBuf[256];
  char  szIdent[FIBER_IDENTLEN*4+1];
  char  szSubKey[256];
  BOOL  fRet = TRUE;
  int   i,c;
  DWORD dwDisposition;
  char  *pt;

  ret = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
			FIBER_SUBKEY,
			0,
			"",
			0,
			KEY_READ|KEY_WRITE,
			NULL,
			&hKey,
			&dwDisposition );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot open registry.\n");
    return ( FALSE );
  }

  c=0;
  for ( i=0; i<iEfs; i++ ){
    if ( ef[i].szExt[0] != 0 ){
      sprintf(szSubKey,"%s%d",FIBER_SUBKEY_EXTENSION,c);
      if ( (ef[i].szIdent[0]>=0x20) && (ef[i].szIdent[0]<0x80) ){
	memcpy( szIdent, ef[i].szIdent, ef[i].dwIdentLength );
	pt = szIdent + ef[i].dwIdentLength;
      } else {
	BinaryToHexString(ef[i].szIdent,ef[i].dwIdentLength,szIdent,sizeof(szIdent));
	pt = szIdent + ef[i].dwIdentLength*4;
      }
      *pt = '\0';
      if ( ef[i].dwOffset == 0 ){
	sprintf(szBuf,"%s=%s",ef[i].szExt,szIdent);
      } else {
	sprintf(szBuf,"%s=%s,%ld",ef[i].szExt,szIdent,ef[i].dwOffset);
      }
      ret = RegSetValueEx( hKey, szSubKey, 0, REG_SZ, szBuf, strlen(szBuf)+1 );
      if ( ret != ERROR_SUCCESS ){
	fRet = FALSE;
	break;
      }
      c++;
    } /* if ( ef[i].szExt[0] != 0 ){ */
  } /* for ( i=0; i<iEfs; i++ ){ */
  if ( fRet )
    for ( i=c; i<iExtNum; i++ ){
      sprintf(szSubKey,"%s%d",FIBER_SUBKEY_EXTENSION,i);
      RegDeleteValue( hKey, szSubKey );
    }

  RegCloseKey( hKey );

  return ( fRet );
}


BOOL InitializeRegistry( VOID )
{
  DWORD ret;
  HKEY  hKey;
  BOOL  fRet = TRUE;
  DWORD dwDisposition;
  int   i;
  char  szBuf[64];

  ret = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
			FIBER_SUBKEY,
			0,
			"",
			0,
			KEY_READ|KEY_WRITE,
			NULL,
			&hKey,
			&dwDisposition );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot create registry.\n");
    return ( FALSE );
  }

  szBuf[0] = FIBER_EXTNUM;
  ret = RegSetValueEx( hKey, FIBER_SUBKEY_EXTNUM, 0,
		       REG_BINARY, szBuf, 1 );
  if ( ret != ERROR_SUCCESS ){
    fRet = FALSE;
    goto Exit;
  }

  ret = RegSetValueEx( hKey, FIBER_SUBKEY_EXECUTEUNKNOWNEXT, 0,
		       REG_BINARY, "\x1", 1 );
  if ( ret != ERROR_SUCCESS ){
    fRet = FALSE;
    goto Exit;
  }
  ret = RegSetValueEx( hKey, FIBER_SUBKEY_EXECUTEURL, 0,
		       REG_BINARY, "\x1", 1 );
  if ( ret != ERROR_SUCCESS ){
    fRet = FALSE;
    goto Exit;
  }
  ret = RegSetValueEx( hKey, FIBER_SUBKEY_TRUSTEXT, 0,
		       REG_BINARY, "\x1", 1 );
  if ( ret != ERROR_SUCCESS ){
    fRet = FALSE;
    goto Exit;
  }
  ret = RegSetValueEx( hKey, FIBER_SUBKEY_OVERRIDEEXT, 0,
		       REG_BINARY, "\x1", 1 );
  if ( ret != ERROR_SUCCESS ){
    fRet = FALSE;
    goto Exit;
  }
  RegCloseKey( hKey );

  /* init ef */
  iExtNum = FIBER_EXTNUM;
  ef = efInit;
  i=0;
  while ( ef[i].dwIdentLength != 0 ) i++;
  iEfs = ++i;

  /* write ef */
  WriteRegistry();

 Exit:
  return ( fRet );
}


BOOL ReadRegistry( VOID )
{
  DWORD ret;
  HKEY  hKey;
  char  szBuf[256];
  DWORD dwBufLen;
  char  szSubKey[256];
  BOOL  fRet = TRUE;
  int   i;

  ret = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
		      FIBER_SUBKEY,
		      0,
		      KEY_EXECUTE,
		      &hKey );
  if ( ret != ERROR_SUCCESS ){
    if ( InitializeRegistry() ){
      ret = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
			  FIBER_SUBKEY,
			  0,
			  KEY_EXECUTE,
			  &hKey );
      if ( ret != ERROR_SUCCESS ) return ( FALSE );
    } else {
      printf("Error: cannot open registry.\n");
      return ( FALSE );
    }
  }

  dwBufLen = sizeof(szBuf);
  ret = RegQueryValueEx( hKey,
			 FIBER_SUBKEY_EXTNUM,
			 NULL,
			 NULL,
			 szBuf,
			 &dwBufLen );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot query [%s] from registry.\n",FIBER_SUBKEY_EXTNUM);
    fRet = FALSE;
    goto Exit;
  }
  iExtNum = szBuf[0];

  dwBufLen = sizeof(szBuf);
  ret = RegQueryValueEx( hKey,
			 FIBER_SUBKEY_EXECUTEUNKNOWNEXT,
			 NULL,
			 NULL,
			 szBuf,
			 &dwBufLen );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot query [%s] from registry.\n",FIBER_SUBKEY_EXECUTEUNKNOWNEXT);
    fRet = FALSE;
    goto Exit;
  }
  fExecuteUnknownExt = ( szBuf[0] == 0 ) ? FALSE : TRUE;
  
  dwBufLen = sizeof(szBuf);
  ret = RegQueryValueEx( hKey,
			 FIBER_SUBKEY_EXECUTEURL,
			 NULL,
			 NULL,
			 szBuf,
			 &dwBufLen );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot query [%s] from registry.\n",FIBER_SUBKEY_EXECUTEURL);
    fRet = FALSE;
    goto Exit;
  }
  fExecuteURL = ( szBuf[0] == 0 ) ? FALSE : TRUE;
  
  dwBufLen = sizeof(szBuf);
  ret = RegQueryValueEx( hKey,
			 FIBER_SUBKEY_TRUSTEXT,
			 NULL,
			 NULL,
			 szBuf,
			 &dwBufLen );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot query [%s] from registry.\n",FIBER_SUBKEY_TRUSTEXT);
    fRet = FALSE;
    goto Exit;
  }
  fTrustExt = ( szBuf[0] == 0 ) ? FALSE : TRUE;
  
  dwBufLen = sizeof(szBuf);
  ret = RegQueryValueEx( hKey,
			 FIBER_SUBKEY_OVERRIDEEXT,
			 NULL,
			 NULL,
			 szBuf,
			 &dwBufLen );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot query [%s] from registry.\n",FIBER_SUBKEY_OVERRIDEEXT);
    fRet = FALSE;
    goto Exit;
  }
  fOverrideExt = ( szBuf[0] == 0 ) ? FALSE : TRUE;

  ef = (EXTFILE*)malloc(sizeof(EXTFILE)*iExtNum);
  if ( ef == NULL ){
    printf("Error: Not enough memory.\n");
    fRet = FALSE;
    goto Exit;
  }

  for ( i=0; i<iExtNum; i++ )
    ef[i].szExt[0] = 0;

  for ( iEfs=0; iEfs<iExtNum; iEfs++ ){
    dwBufLen = sizeof(szBuf);
    sprintf(szSubKey,"%s%d",FIBER_SUBKEY_EXTENSION,iEfs);
    ret = RegQueryValueEx( hKey, szSubKey, NULL, NULL, szBuf, &dwBufLen );
    if ( ret != ERROR_SUCCESS ) break;
    if ( ! SetEf( &ef[iEfs], szBuf ) ) break;
  } /* for ( iEfs=0; iEfs<iExtNum; iEfs++ ){ */
 Exit:
  RegCloseKey( hKey );

  return ( fRet );
}


int CheckFileType( LPSTR szInputFile )
{
  int    i;
  HANDLE hFile;
  char   szBuf[FIBER_IDENTLEN+1];
  DWORD  dwLen;

  for ( i=0; i<iEfs; i++ ){
    hFile = CreateFile(szInputFile,
		       GENERIC_READ,
		       FILE_SHARE_READ,
		       NULL,
		       OPEN_EXISTING,
		       0,
		       NULL);
    if ( hFile == INVALID_HANDLE_VALUE ) continue;
    if ( SetFilePointer(hFile,ef[i].dwOffset,NULL,FILE_BEGIN) != 0xFFFFFFFF ){
      ReadFile(hFile,szBuf,ef[i].dwIdentLength,&dwLen,NULL);
      if ( memcmp(szBuf,ef[i].szIdent,ef[i].dwIdentLength) == 0 ){
	CloseHandle( hFile );
	break;
      }
    } else {
      printf("Error: SetFilePointer fail.\n");
    } /* if ( SetFilePointer(hFile,ef[i].dwOffset,NULL,FILE_BEGIN) != 0xFFFFFFFF ){ */
    CloseHandle( hFile );
  } /* for ( i=0; i<iEfs; i++ ){ */
  if ( i == iEfs )
    return ( INT_MAX );
  else
    return ( i );
}


int SearchExtension( char *ext )
{
  int i;

  for ( i=0; i<iEfs; i++ )
    if ( strcmpi(ext,ef[i].szExt) == 0 ) break;

  if ( i == iEfs )
    return ( INT_MAX );
  else
    return ( i );
}


int GetExtension( char *lpszInputFile )
{
  char *pt;
  int  n;
  char szFileName[MAX_PATH];

  GetFileNameFromFullPath(lpszInputFile,szFileName,sizeof(szFileName));
  pt = strrchr(szFileName,'.');
  if ( pt == NULL ){
    n = INT_MAX;		/* ext is not found */
  } else {
    n = SearchExtension(++pt);
    if ( n == INT_MAX ) n = INT_MAX-1;
  }
  return ( n );
}


VOID PrintYesOrNo( BOOL flag )
{
  if ( flag )
    printf("yes\n");
  else
    printf("no\n");
}


VOID PrintOptions( VOID )
{
  printf("\n");
  printf(" OPTION            = VALUE\n");
  printf("---------------------------\n");

  printf(" ExtNum            = %d\n",iExtNum);
  printf(" ExecuteUnknownExt = ");
  PrintYesOrNo(fExecuteUnknownExt);
  printf(" ExecuteURL        = ");
  PrintYesOrNo(fExecuteURL);
  printf(" TrustExt          = ");
  PrintYesOrNo(fTrustExt);
  printf(" OverrideExt       = ");
  PrintYesOrNo(fOverrideExt);
}


VOID PrintExts( VOID )
{
  int i;
  char szBuf[256];

  printf("\n");
  printf(" ID : EXT=OFFSET\n");
  printf("-----------------\n");

  for ( i=0; i<iEfs; i++ ){
    if ( ef[i].szExt[0] == 0 ) break;
    if ( (ef[i].szIdent[0]>=0x20)&&(ef[i].szIdent[0]<0x80) ){
      strcpy(szBuf,ef[i].szIdent);
    } else {
      BinaryToHexString(ef[i].szIdent,ef[i].dwIdentLength,szBuf,sizeof(szBuf));
    }
    printf("%3d : %s=%s,%ld\n",i,ef[i].szExt,szBuf,ef[i].dwOffset);
  } /* for ( i=0; i<iEfs; i++ ){ */
}


BOOL SetOption( LPSTR szOption )
{
  LPSTR pt;
  int   num;
  char  opt;
  DWORD ret;
  HKEY  hKey;
  DWORD dwDisposition;
  BOOL  fRet=TRUE;

  pt = _mbschr( szOption, '=' );
  if ( pt == NULL ){
    printf("Error: illegal option format.\n");
    return ( FALSE );
  }
  *pt++ = '\0';

  ret = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
			FIBER_SUBKEY,
			0,
			"",
			0,
			KEY_READ|KEY_WRITE,
			NULL,
			&hKey,
			&dwDisposition );
  if ( ret != ERROR_SUCCESS ){
    printf("Error: cannot open registry.\n");
    return ( FALSE );
  }

  if ( ! strcmp( FIBER_SUBKEY_EXTNUM, szOption ) ){
    /* ExtNum */
    num = atoi( pt );
    if ( num >= 256 ){
      printf("Error: too large number.\n");
      fRet = FALSE;
    } else if ( num > 0 ){
      opt = (char)num;
      ret = RegSetValueEx( hKey, FIBER_SUBKEY_EXTNUM, 0, REG_BINARY, &opt, 1 );
    } /* if ( num >= 256 ){ */
  } else if ( ! strcmp( FIBER_SUBKEY_EXECUTEUNKNOWNEXT, szOption ) ||
	      ! strcmp( FIBER_SUBKEY_EXECUTEURL, szOption ) ||
	      ! strcmp( FIBER_SUBKEY_TRUSTEXT, szOption ) ||
	      ! strcmp( FIBER_SUBKEY_OVERRIDEEXT, szOption ) ){
    if ( ! strcmp( pt, "no" ) )
      opt = 0;
    else if ( ! strcmp( pt, "yes" ) )
      opt = 1;
    else
      opt = 2;
    if ( opt != 2 ){
      ret = RegSetValueEx( hKey, szOption, 0, REG_BINARY, &opt, 1 );
    } else {
      printf("Error: please set OPTIONAME={yes,no}.\n");
      fRet = FALSE;
    } /* if ( opt != 2 ){ */
  } else {
    printf("Error: unknown option.\n");
    fRet = FALSE;
  }
  RegCloseKey( hKey );

  return ( fRet );
}


VOID ShellExecuteOpenSync( SHELLEXECUTEINFO *lpsei,
			   BOOL    fSynchronous,
			   BOOL    fDelete )
{
  BOOL             fRet;
  DWORD            dwRet;

  fRet = ShellExecuteEx( lpsei );
#ifdef _DEBUG
  printf("fRet=[%08x]\n", fRet);
  printf("hProcess=[%08x]\n", lpsei->hProcess);
#endif
  if ( fRet ){
    if ( fSynchronous && lpsei->hProcess != NULL ){
      dwRet = WaitForSingleObject( lpsei->hProcess, INFINITE );
      if ( dwRet == WAIT_FAILED )
	printf("Error: WaitForSingleObject fail.(%ld)\n",GetLastError());
      if ( fDelete )
	DeleteFile( lpsei->lpFile );
    } /* if ( fSynchronous ){ */
  } else {
    printf("Error: ShellExecuteEx fail.(%ld)\n",GetLastError());
  } /* if ( fRet ){ */
}

VOID PrintUsage( VOID )
{
  printf("File Inspect and Broking End Resolver  Version %s\n",FIBER_VERSION);
  printf("        Copyright (C) 1997-2004  Shuichi Kitaguchi\n");
  printf("\n");
  printf("Usage : fiber [option] <filename>\n");
  printf("Option:     -e ext                 assume that the extention is \"ext\"\n");
  printf("            -s                     synchronous mode\n");
  printf("            -a ext=ident,offset    add ext to database\n");
  printf("            -l                     list options and database\n");
  printf("            -r num                 remove ext indentified by num from database\n");
  printf("            -o Option={num,yes/no} set option\n");
  printf("            -i                     initialize database\n");
  printf("            -p parameters          set parameters\n");
  printf("            -n show                ShowWindow parameter \"nCmdShow\"\n");
  printf("            -b verb                name of verb(action)\n");
  printf("            -d directory           working directory\n");
}

/*
 * before ShellExecuteEx() "home.txt" or "www.txt",
 * internet browser is launched. when executing full
 * path name, browser is not launched. why?
 */
VOID
ConvertToFullPathName( LPSTR lpInputFile )
{
  char  szFullName[MAX_PATH];
  LPSTR lpFullName;
  DWORD dwLen;
  
  dwLen = GetFullPathName( lpInputFile, sizeof(szFullName),
			   szFullName, &lpFullName );
  if ( dwLen < sizeof(szFullName )){
    strcpy(lpInputFile, szFullName);
  } else if ( dwLen >= sizeof(szFullName) ){
    printf("Error: conversion buffer is small for [%s]\n",lpInputFile);
  } else {
    printf("Error: GetFullPathName fail.(%ld)\n",GetLastError());
  }
}

int
main( int  argc, char *argv[] )
{
  int  i,ri;
  char szInputFile[MAX_PATH];
  char szOpenFile[MAX_PATH];
  char *pt;
  int  state;
  char szExt[FIBER_EXTLEN];
  char szAddExt[FIBER_EXTLINELEN];
  char szOption[FIBER_OPTIONLEN];
  BOOL fExt         = FALSE;
  BOOL fError       = FALSE;
  BOOL fList        = FALSE;
  BOOL fAdd         = FALSE;
  BOOL fRemove      = FALSE;
  BOOL fInitialize  = FALSE;
  BOOL fOption      = FALSE;
  BOOL fSynchronous = FALSE;
  int  iRemoveNum;
  SHELLEXECUTEINFO sei;
#ifdef _DEBUG
  FILE *fp;
#endif

  szInputFile[0] = 0;
  szOpenFile[0]  = 0;

  memset( &sei, 0, sizeof(sei) );
  sei.cbSize       = sizeof(sei);
  sei.fMask        = SEE_MASK_NOCLOSEPROCESS|SEE_MASK_FLAG_DDEWAIT;
  sei.nShow        = SW_SHOWNORMAL;

  /* parse arguments */
  i=1;
  while ( i < argc ){
    if ( ! strcmp(argv[i],"-e") ){
      /* -e */
      fExt=TRUE;
      if ( (i+1) < argc ){
	if ( strlen(argv[i+1]) >= sizeof(szExt) ){
	  printf("Error: ext [%s] is too long.\n",argv[i+1]);
	  exit( -1 );
	}
	strcpy(szExt,argv[i+1]);
	i++;
      } else {
	printf("Error: ext is required with \'-e\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-a") ){
      /* -a */
      fAdd = TRUE;
      if ( (i+1) < argc ){
	if ( strlen(argv[i+1]) >= sizeof(szAddExt) ){
	  printf("Error: ext [%s] is too long.\n",argv[i+1]);
	  exit( -1 );
	}
	strcpy(szAddExt,argv[i+1]);
	i++;
      } else {
	printf("Error: ext is required with \'-a\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-r") ){
      /* -r */
      fRemove = TRUE;
      if ( (i+1) < argc ){
	iRemoveNum = atoi(argv[i+1]);
	i++;
      } else {
	printf("Error: number is required with \'-r\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-o") ){
      /* -o */
      fOption = TRUE;
      if ( (i+1) < argc ){
	if ( strlen(argv[i+1]) >= sizeof(szOption) ){
	  printf("Error: ext [%s] is too long.\n",argv[i+1]);
	  exit( -1 );
	}
	strcpy(szOption,argv[i+1]);
	i++;
      } else {
	printf("Error: Option is required with \'-o\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-l") ){
      /* -l */
      fList = TRUE;
    } else if ( ! strcmp(argv[i],"-i") ){
      /* -i */
      fInitialize = TRUE;
    } else if ( ! strcmp(argv[i],"-s") ){
      fSynchronous = TRUE;
    } else if ( ! strcmp(argv[i],"-p") ){
      /* -p */
      if ( (i+1) < argc ){
	sei.lpParameters = argv[i+1];
	i++;
      } else {
	printf("Error: parameter is required with \'-p\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-n") ){
      /* -n */
      if ( (i+1) < argc ){
	sei.nShow = atoi(argv[i+1]);
	if ( sei.nShow == 0 ) sei.nShow = SW_SHOWNORMAL;
	i++;
      } else {
	printf("Error: show is required with \'-n\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-b") ){
      /* -b */
      if ( (i+1) < argc ){
	sei.lpVerb = argv[i+1];
	i++;
      } else {
	printf("Error: verb(action) is required with \'-b\' option.\n");
	fError=TRUE;
      }
    } else if ( ! strcmp(argv[i],"-d") ){
      /* -d */
      if ( (i+1) < argc ){
	sei.lpDirectory = argv[i+1];
	i++;
      } else {
	printf("Error: directory name is required with \'-b\' option.\n");
	fError=TRUE;
      }
    } else {
      /* filename */
      if ( strlen(argv[i]) > sizeof(szInputFile) ){
	printf("Error: specified filename [%s] is too long.\n",argv[i]);
	fError=TRUE;
      } else {
	strcpy(szInputFile,argv[i]);
      }
      break;
    }
    i++;
  }

  /* show usage */
  if ( (argc==1) || (fError==TRUE) ){
    PrintUsage();
    exit( 0 );
  }

  /* read registry database */
  if ( ! ReadRegistry() ) exit( -1 );

  /* initialize */
  if ( fInitialize ){
    if ( InitializeRegistry() )
      exit( 0 );
    else
      exit( -1 );
  } /* if ( fInitialize ){ */

  /* set option */
  if ( fOption ){
    if ( SetOption(szOption) )
      exit( 0 );
    else
      exit( -1 );
  } /* if ( fOption ){ */
    
  /* add */
  if ( fAdd ){
    if ( (iEfs+1) > iExtNum ){
      printf("Error: cannot add ext (too many exts).\n");
      exit( -1 );
    }
    if ( ! SetEf(&ef[iEfs],szAddExt) ) exit( -1 );
    iEfs++;
    ef[iEfs].szExt[0] = 0;
    if ( ! WriteRegistry() ) exit( -1 );
    printf("ext [%s] is added.\n",ef[iEfs-1].szExt);
    exit( 0 );
  } /* if ( fAdd ){ */

  /* remove */
  if ( fRemove ){
    if ( iRemoveNum > iExtNum ){
      printf("Error: num is too large.\n");
      exit( -1 );
    }
    ef[iRemoveNum].szExt[0] = 0;
    if ( ! WriteRegistry() ) exit( -1 );
    printf("Id [%d] is removed.\n",iRemoveNum);
    exit( 0 );
  }

  /* list */
  if ( fList ){
    PrintOptions();
    PrintExts();
    exit( 0 );
  } /* if ( fList ){ */

  
#if 0	/* Windows' "file:" scheme is very funny... */
  /* eliminate "file:" scheme. */
  if( (strlen(szInputFile) >= 5) &&
      strncmp("file:", szInputFile, 5) == 0 ){
    memmove( szInputFile, &szInputFile[5], strlen(szInputFile)-5+1 );
  }
#endif

  /* set ext and execute */
  if ( fExt ){
    sprintf(szOpenFile,"%s.%s",szInputFile,szExt);
    ConvertToFullPathName(szOpenFile);
    if ( CheckFile( szOpenFile ) ){
      sei.lpFile = szOpenFile;
      ShellExecuteOpenSync( &sei, fSynchronous, FALSE );
    } else {
      CopyFile(szInputFile,szOpenFile,FALSE);
      sei.lpFile = szOpenFile;
      ShellExecuteOpenSync( &sei, fSynchronous, TRUE );
    }
    exit( 0 );
  } /* if ( fExt ){ */

  /* execute URL */
  if ( fExecuteURL ){
    pt = strchr(szInputFile,':');
    if ( pt ){
      if ( pt > (szInputFile+1) ){ /* "http:","ftp:",... */
	sei.lpFile = szInputFile;
	ShellExecuteOpenSync( &sei, fSynchronous, FALSE );
	exit( 0 );
      }
    } /* if ( pt ){ */
  } /* if ( fExecuteURL ){ */

  ConvertToFullPathName(szInputFile);
  RevConvertPathSeparator(szInputFile);

  i = CheckFileType(szInputFile);
  ri = GetExtension(szInputFile);
  /*
   * INT_MAX   - no exts.
   * INT_MAX-1 - unknown exts.
   *
   * state =  0 - error
   *          1 - szInputFile
   *          2 - add ext
   */

  if ( i == INT_MAX ){
    switch ( ri ){
    case INT_MAX:
      state = STATE_ERROR;
      break;
    case INT_MAX-1:
      state = ( fExecuteUnknownExt ) ? STATE_INPUTFILE : STATE_ERROR;
      break;
    default:
      state = ( fExecuteUnknownExt ) ? STATE_INPUTFILE : STATE_ERROR;
      break;
    }    
  } else {
    switch ( ri ){
    case INT_MAX:
      state = STATE_ADDEXT;
      break;
    case INT_MAX-1:
      state = ( fOverrideExt ) ? STATE_ADDEXT : STATE_INPUTFILE;
      break;
    default:
      state = ( fTrustExt ) ? STATE_INPUTFILE : STATE_ADDEXT;
      break;
    }
  } /* if ( i == INT_MAX ){ */
#ifdef _DEBUG
  fp = fopen("C:\\TEMP\\FIBER.LOG","a+");
  fprintf(fp,"InputFile=[%s],i=[%d]/ri=[%d],state=[%d]\n",szInputFile,i,ri,state);
  fclose(fp);
  printf("InputFile=[%s],i=[%d]/ri=[%d],state=[%d]\n",szInputFile,i,ri,state);
#endif
  /* go! */
  switch ( state ){
  case STATE_INPUTFILE:
    sei.lpFile = szInputFile;
    ShellExecuteOpenSync( &sei, fSynchronous, FALSE );
    break;
  case STATE_ADDEXT:
    sprintf(szOpenFile,"%s.%s",szInputFile,ef[i].szExt);
    if ( CheckFile( szOpenFile ) ){
      sei.lpFile = szOpenFile;
      ShellExecuteOpenSync( &sei, fSynchronous, FALSE );
    } else {
      CopyFile(szInputFile,szOpenFile,FALSE);
      sei.lpFile = szOpenFile;
      ShellExecuteOpenSync( &sei, fSynchronous, TRUE );
    }
    break;
  default:
    printf("Error: file not found or not supported.\n");
    break;
  } /* switch ( state ){ */
  exit ( 0 );
}