home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 106 / EnigmaAmiga106CD.iso / software / utilities / hexy / src / hexy_functions.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-08-23  |  11.6 KB  |  467 lines
  1.  
  2. /*
  3.  * [!BGN - MACHINE GENERATED - DO NOT EDIT THIS HEADER]
  4.  *
  5.  * Program   : Hexy (Binary file viewer/editor for the Amiga.)
  6.  * Version   : 1.6
  7.  * File      : Work:Source/!WIP/HisoftProjects/Hexy/Hexy_functions.c
  8.  * Author    : Andrew Bell
  9.  * Copyright : Copyright © 1998-1999 Andrew Bell (See GNU GPL)
  10.  * Created   : Saturday 28-Feb-98 16:00:00
  11.  * Modified  : Sunday 22-Aug-99 23:31:45
  12.  * Comment   : 
  13.  *
  14.  * (Generated with StampSource 1.2 by Andrew Bell)
  15.  *
  16.  * [!END - MACHINE GENERATED - DO NOT EDIT THIS HEADER]
  17.  *
  18.  */
  19.  
  20. /* Created: Sun/09/Aug/1998 */
  21.  
  22. /*
  23.  *  Hexy, binary file viewer and editor for the Amiga.
  24.  *  Copyright (C) 1999 Andrew Bell
  25.  *
  26.  *  Author's email address: andrew.ab2000@bigfoot.com
  27.  *
  28.  *  This program is free software; you can redistribute it and/or modify
  29.  *  it under the terms of the GNU General Public License as published by
  30.  *  the Free Software Foundation; either version 2 of the License, or
  31.  *  (at your option) any later version.
  32.  *
  33.  *  This program is distributed in the hope that it will be useful,
  34.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  35.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  36.  *  GNU General Public License for more details.
  37.  *
  38.  *  You should have received a copy of the GNU General Public License
  39.  *  along with this program; if not, write to the Free Software
  40.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  41.  *
  42.  */
  43.  
  44. #include <Hexy.h>
  45.  
  46. /* Prototypes */
  47.  
  48. Prototype BOOL UnpackFile(struct VCtrl *TmpVC);
  49. Prototype BOOL CheckForViruses(struct VCtrl *TmpVC);
  50. Prototype UWORD CheckXPK(struct VCtrl *TmpVC);
  51. Prototype ULONG ConvertBinStr(void *Source, void *Dest);
  52. Prototype void UpdateBinResult( void );
  53. Prototype void DisplayFileInfos(struct VCtrl *TmpVC);
  54. Prototype BOOL ValidFile(struct VCtrl *TmpVC);
  55. Prototype BOOL LMBActive( void );
  56. Prototype void FreeVC(struct VCtrl *TmpVC);
  57. Prototype void FlashScreen( void );
  58. Prototype BOOL EnableFlash;
  59. Prototype struct Library *xfdMasterBase;
  60. Prototype struct Library *FilevirusBase;
  61. Prototype struct Library *XpkBase;
  62. Prototype struct XpkFib *XFIB;
  63.  
  64. /* Variables and data */
  65.  
  66. BOOL EnableFlash = TRUE;
  67. struct Library *xfdMasterBase = NULL;
  68. struct Library *FilevirusBase = NULL;
  69. struct Library *XpkBase = NULL;
  70. struct XpkFib *XFIB = NULL;
  71.  
  72. void FlashScreen( void )
  73. {
  74.   /*************************************************
  75.    *
  76.    * Special flash routine for Hexy 
  77.    *
  78.    */
  79.  
  80.   if (EnableFlash) DisplayBeep(Scr);
  81. }
  82.  
  83. BOOL UnpackFile(struct VCtrl *TmpVC)
  84. {
  85.   /*************************************************
  86.    *
  87.    * Unpack the file using xfdmaster.library
  88.    *
  89.    */
  90.  
  91.   BOOL Result = FALSE;
  92.   struct xfdBufferInfo *xfdBI;
  93.   UWORD uresult = CheckXPK(TmpVC);
  94.   ULONG TempLen;
  95.  
  96.   if (uresult == HEXYUCODE_NOTPACKED || uresult == HEXYUCODE_ABORT) return TRUE;
  97.  
  98.   /* Create a CheckXFD() sub, then move this code to it! */
  99.  
  100.   if (xfdMasterBase = OpenLibrary("xfdmaster.library", 38L))
  101.   {
  102.     if (xfdBI = (struct xfdBufferInfo *) xfdAllocObject(XFDOBJ_BUFFERINFO))
  103.     {
  104.       xfdBI->xfdbi_SourceBuffer = TmpVC->VC_FileAddress;
  105.       xfdBI->xfdbi_SourceBufLen = TmpVC->VC_FileLength;
  106.  
  107.       if (xfdRecogBuffer(xfdBI))
  108.       {
  109.         /* XFDPFB_USERTARGET may cause some problems */
  110.  
  111.         struct EasyStruct PackES =
  112.         {
  113.           sizeof(struct EasyStruct),
  114.           NULL,
  115.           "File info...",
  116.           "File is compressed with\n[ %s ]\nDecompress it?",
  117.           "Yes|No"
  118.         };
  119.  
  120.         stream[0] = (ULONG) xfdBI->xfdbi_PackerName;
  121.         if (EasyRequestArgs(MAINWnd, &PackES, NULL, &stream))
  122.         {
  123.  
  124.           /* Check for password here */
  125.  
  126.           xfdBI->xfdbi_Flags |= XFDFF_USERTARGET;
  127.           TempLen = xfdBI->xfdbi_MinTargetLen;
  128.           if (TempLen)
  129.           {
  130.             APTR TempVec;
  131.             if (TempVec = AllocVec(TempLen, xfdBI->xfdbi_TargetBufMemType))
  132.             {
  133.               xfdBI->xfdbi_UserTargetBuf = TempVec;
  134.               xfdBI->xfdbi_UserTargetBufLen = TempLen;
  135.               stream[0] = (ULONG)xfdBI->xfdbi_PackerName;
  136.               PrintStatus("Please wait, decrunching file (%.40s)...", &stream);
  137.  
  138.               if (xfdDecrunchBuffer(xfdBI))
  139.               {
  140.                 FreeVec(TmpVC->VC_FileAddress);
  141.                 TmpVC->VC_FileAddress = TempVec;
  142.                 TmpVC->VC_FileLength = xfdBI->xfdbi_FinalTargetLen;
  143.                 TmpVC->VC_CurrentPoint = NULL;
  144.                 Result = TRUE;
  145.               }
  146.               else
  147.               {
  148.                 PrintStatus("Failed to decompress file!", &stream);
  149.               }
  150.             }
  151.             else
  152.             {
  153.               PrintStatus("No memory to decompress file!", &stream);
  154.             }
  155.           }
  156.         }
  157.         else
  158.         {
  159.           PrintStatus("File NOT decompressed!", &stream);
  160.         }
  161.       }
  162.       xfdFreeObject(xfdBI);
  163.     }
  164.     CloseLibrary(xfdMasterBase);
  165.     xfdMasterBase = NULL;
  166.   }
  167.   return Result;
  168. }
  169.  
  170. BOOL CheckForViruses(struct VCtrl *TmpVC)
  171. {
  172.   /*************************************************
  173.    *
  174.    * Check file for viruses 
  175.    *
  176.    */
  177.  
  178.   /* Returns TRUE if file is infected with a virus. */
  179.  
  180.   /* Note, August 1999:
  181.   
  182.      Following code was removed because filevirus.library is out
  183.      of date. Development of it has stopped. Maybe one day I'll
  184.      add support for xvs.library. */
  185.  
  186. /*
  187.   if (FilevirusBase = OpenLibrary("filevirus.library", 2))
  188.   {
  189.     struct FilevirusNode *fvnode;
  190.  
  191.     if (fvnode = (struct FilevirusNode *) fvAllocNode())
  192.     {
  193.       fvnode->fv_Buffer = TmpVC->VC_FileAddress;
  194.       fvnode->fv_BufferLen = TmpVC->VC_FileLength;
  195.  
  196.       if (!fvCheckFile(fvnode, NULL))
  197.       {
  198.         if (fvnode->fv_FileInfection)
  199.         {
  200.           stream[0] = (ULONG) fvnode->fv_FileInfection->fi_VirusName;
  201.  
  202.           struct EasyStruct VirusES =
  203.           {
  204.             sizeof(struct EasyStruct),
  205.             NULL,
  206.             "WARNING!!!",
  207.             "This file seems to be infected with the\n'%s'\nvirus!!!",
  208.             "Oh Shit!"
  209.           };
  210.           EasyRequestArgs(MAINWnd, &VirusES, NULL, &stream);
  211.  
  212.         }
  213.       }
  214.  
  215.       fvFreeNode(fvnode);
  216.     }
  217.  
  218.     CloseLibrary(FilevirusBase); FilevirusBase = NULL;
  219.   }
  220. */
  221.   return FALSE;
  222. }
  223.  
  224. UWORD CheckXPK(struct VCtrl *TmpVC)
  225. {
  226.   /*************************************************
  227.    *
  228.    * Check and see if the file has been compressed with XPK
  229.    *
  230.    */
  231.  
  232.   BOOL Result = HEXYUCODE_NOTPACKED;
  233.  
  234.   if (XpkBase = OpenLibrary("xpkmaster.library", 5L))
  235.   {
  236.     if (XFIB = (struct XpkFib*) XpkAllocObject(XPKOBJ_FIB, NULL))
  237.     {
  238.       stream[0] = (ULONG) XPK_InBuf;
  239.       stream[1] = (ULONG) TmpVC->VC_FileAddress;
  240.       stream[2] = (ULONG) XPK_InLen;
  241.       stream[3] = (ULONG) TmpVC->VC_FileLength;
  242.       stream[4] = (ULONG) TAG_DONE;
  243.       if (!XpkExamine(XFIB, (struct TagItem *) &stream))
  244.       {
  245.         if (XFIB->xf_Type == XPKTYPE_PACKED)
  246.         {
  247.           struct EasyStruct PackES =
  248.           {
  249.             sizeof(struct EasyStruct),
  250.             NULL,
  251.             "File info...",
  252.             "File is compressed with\n[ XPK METHOD %.4s ]\nDecompress it?",
  253.             "Yes|No"
  254.           };
  255.           stream[0] = (ULONG) &XFIB->xf_Packer;
  256.           if (EasyRequestArgs(MAINWnd, &PackES, NULL, &stream))
  257.           {
  258.             APTR TempVec;
  259.             ULONG TempVecRealLen = XFIB->xf_ULen;
  260.             ULONG TempVecLen = TempVecRealLen + XPK_MARGIN;
  261.             if (TempVec = AllocVec(TempVecLen, MEMF_ANY))
  262.             {
  263.               LONG XPKECODE;
  264.               stream[0] = (ULONG) &XFIB->xf_Packer;
  265.               PrintStatus("Please wait, decrunching XPK file (%-4.4s)...", &stream);
  266.               stream[0] = (ULONG) XPK_InBuf;
  267.               stream[1] = (ULONG) TmpVC->VC_FileAddress;
  268.               stream[2] = (ULONG) XPK_InLen;
  269.               stream[3] = (ULONG) TmpVC->VC_FileLength;
  270.               stream[4] = (ULONG) XPK_OutBuf;
  271.               stream[5] = (ULONG) TempVec;
  272.               stream[6] = (ULONG) XPK_OutBufLen;
  273.               stream[7] = (ULONG) TempVecLen;
  274.               stream[8] = (ULONG) TAG_DONE;
  275.               if (!(XPKECODE = XpkUnpack( (struct TagItem *) &stream)))
  276.               {
  277.                 FreeVec(TmpVC->VC_FileAddress);
  278.                 TmpVC->VC_FileAddress = TempVec;
  279.                 TmpVC->VC_FileLength = TempVecRealLen;
  280.                 TmpVC->VC_CurrentPoint = NULL;
  281.                 Result = HEXYUCODE_OK;
  282.               }
  283.               else
  284.               {
  285.                 stream[0] = XPKECODE;
  286.                 PrintStatus("XPK decompression failed (XPK ERROR CODE: %ld)", &stream);
  287.                 FlashScreen();
  288.                 Result = HEXYUCODE_ABORT;
  289.               }
  290.             }
  291.           }
  292.         }
  293.       }
  294.       XpkFreeObject(XPKOBJ_FIB ,XFIB);
  295.     }
  296.     CloseLibrary(XpkBase); XpkBase = NULL;
  297.   }
  298.   return Result;
  299. }
  300.  
  301. ULONG ConvertBinStr(void *Source, void *Dest)
  302. {
  303.   ULONG Len = 0;
  304.  
  305.   /* This code was removed for the public release, too buggy :( */
  306.  
  307.   return 0;
  308.   
  309.   /*************************************************
  310.    *
  311.    * Convert "hello",1,$5f,4,5,51 to binary, etc.
  312.    *
  313.    */
  314.  
  315.   if (strlen(Source) > 128)
  316.   {
  317.     PrintStatus("String too big!", NULL); return NULL;
  318.   }
  319.  
  320.   /* Len = FmtStrToRaw(Source, Dest, 128L); */
  321.  
  322.   if (Len)
  323.   {
  324.     return Len;
  325.   }
  326.   else
  327.   {
  328.     FlashScreen();
  329.     PrintStatus("Invalid binary string!", NULL);
  330.     return NULL;
  331.   }
  332.   return NULL;
  333. }
  334.  
  335. void UpdateBinResult( void )
  336. {
  337.   UBYTE *Str;
  338.   ULONG Check, Len, r;
  339.  
  340.    /* Note: This is taking up a lot of stack space! */
  341.  
  342.   UBYTE TmpBuf[512+4];
  343.   /*UBYTE FmtBuf[512+4];*/
  344.  
  345.   /* Removed from release version, too buggy :( */
  346.   
  347.   return;
  348.   
  349.   /*************************************************
  350.    *
  351.    * Move this to the findwin module
  352.    *
  353.    */
  354.  
  355.   r = GT_GetGadgetAttrs(FINDGadgets[GD_FGSTRING], MAINWnd, NULL, GTST_String, &Str, TAG_DONE);
  356.  
  357.   if (!r) return;
  358.  
  359.   r = GT_GetGadgetAttrs(FINDGadgets[GD_FGBINSEARCH], MAINWnd, NULL, GTCB_Checked, &Check, TAG_DONE);
  360.  
  361.   if (!r)
  362.   {
  363.     FlashScreen(); return;
  364.   }
  365.   if (Check)
  366.   {
  367.     if (Len = ConvertBinStr(Str, &TmpBuf))
  368.     {
  369.       Str = (UBYTE *) &TmpBuf;
  370.     }
  371.     else return;
  372.   }
  373.   else
  374.   {
  375.     Len = strlen(Str);
  376.   }
  377.  
  378.   /*BinToBinStr(Str, Len, (UBYTE *) &FmtBuf, 512L);
  379.  
  380.   GT_SetGadgetAttrs(FINDGadgets[GD_FGBINRESULT], FINDWnd, NULL,
  381.     GTTX_Text, &FmtBuf,
  382.     TAG_DONE);*/
  383. }
  384.  
  385. UBYTE TitleBuffer[512+4];
  386.  
  387. void DisplayFileInfos(struct VCtrl *TmpVC)
  388. {
  389.   /*************************************************
  390.    *
  391.    * Display info on the file in the title bar
  392.    *
  393.    */
  394.  
  395.   if (TmpVC->VC_FileAddress && MAINWnd)
  396.   {
  397.     stream[0] = (ULONG) &TmpVC->VC_FIB->fib_FileName;
  398.     stream[1] = (ULONG) TmpVC->VC_FileLength;
  399.     RawDoFmt("Hexy screen (%s, %lu bytes)", &stream, (void *) &putChProc, &TitleBuffer);
  400.     SetWindowTitles(MAINWnd, (UBYTE *) -1, (UBYTE *) &TitleBuffer);
  401.   }
  402. }
  403.  
  404. BOOL ValidFile(struct VCtrl *TmpVC)
  405. {
  406.   /*************************************************
  407.    *
  408.    * Check for valid file in a VC 
  409.    *
  410.    */
  411.  
  412.   if (!TmpVC->VC_FileAddress) return FALSE;
  413.   if (!TmpVC->VC_FileLength) return FALSE;
  414.   return TRUE;
  415. }
  416.  
  417. BOOL LMBActive( void )
  418. {
  419.   /*************************************************
  420.    *
  421.    * Check for a press of the LMB
  422.    *
  423.    */
  424.  
  425.   BOOL result = FALSE;
  426.   struct IntuiMessage *TmpIM;
  427.   TmpIM = (struct IntuiMessage *) GT_GetIMsg(WinPort);
  428.  
  429.   if (TmpIM)
  430.   {
  431.     if (TmpIM->Class == IDCMP_MOUSEBUTTONS)
  432.     {
  433.       if (TmpIM->Code == SELECTDOWN) result = TRUE;
  434.     }
  435.     GT_ReplyIMsg(TmpIM);
  436.   }
  437.   return result;
  438. }
  439.  
  440. void FreeVC(struct VCtrl *TmpVC)
  441. {
  442.   /*************************************************
  443.    *
  444.    * Free the contents of a VC struct
  445.    *
  446.    */
  447.  
  448.   if (TmpVC->VC_FIB)
  449.   {
  450.     FreeDosObject(DOS_FIB, TmpVC->VC_FIB);
  451.     TmpVC->VC_FIB = NULL;
  452.   }
  453.  
  454.   if (TmpVC->VC_FileAddress)
  455.   {
  456.     FreeVec(TmpVC->VC_FileAddress);
  457.     TmpVC->VC_FileAddress = NULL;
  458.   }
  459. }
  460.  
  461. /*************************************************
  462.  *
  463.  * 
  464.  *
  465.  */
  466.  
  467.