root/trunk/nt/fiber.c

/*
 * 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, &</