home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1057.lha / Programs / UnLock / UnLock.c < prev    next >
C/C++ Source or Header  |  1995-01-12  |  10KB  |  476 lines
  1. /*
  2. Auto:        sc <file>
  3. Auto:        Protect <file> ADD P
  4. */
  5.  
  6. /* $Revision Header built automatically *************** (do not edit) ************
  7. **
  8. ** © Copyright by GuntherSoft
  9. **
  10. ** File             : SnakeSYS:CPrgs/Unlock/Unlock.c
  11. ** Created on       : Mittwoch, 11.01.95 11:27:56
  12. ** Created by       : Kai Iske
  13. ** Current revision : V37.0
  14. **
  15. **
  16. ** Purpose
  17. ** -------
  18. **     This little program removes all the locks from a given
  19. **     directory.
  20. **
  21. ** Revision V37.0
  22. ** --------------
  23. ** created on Mittwoch, 11.01.95 11:27:56  by  Kai Iske.   LogMessage :
  24. **     --- Initial release ---
  25. **
  26. *********************************************************************************/
  27. #define REVISION "37.0"
  28. #define REVDATE  "11.01.95"
  29. #define REVTIME  "11:27:56"
  30. #define AUTHOR   "Kai Iske"
  31. #define VERNUM   37
  32. #define REVNUM   0
  33.  
  34.  
  35. #include    <string.h>
  36. #include    <stdlib.h>
  37. #include    <stdarg.h>
  38. #include    <exec/types.h>
  39. #include    <proto/exec.h>
  40. #include    <proto/dos.h>
  41. #include    <exec/memory.h>
  42. #include    <exec/execbase.h>
  43. #include    <dos/dos.h>
  44. #include    <dos/dosextens.h>
  45.  
  46.  
  47. /**********************************************************************/
  48. /*                        Version and Template                        */
  49. /**********************************************************************/
  50. static    const char    *Version    = "$VER: UnLock "REVISION" ("REVDATE")\0";
  51. static    const char    *Template    = "DIR/M,SHOW/S";
  52. enum    {OBJECT_ARG, SHOW_ARG, LAST_ARG};
  53.  
  54.  
  55.  
  56.  
  57. /**********************************************************************/
  58. /*                        Function prototypes                         */
  59. /**********************************************************************/
  60. static ULONG UnLockEntry(char *Pattern, char *NameBuffer, char *SpareBuffer, BOOL Show, BOOL *Error);
  61. static void __stdargs SPrintF(STRPTR buffer, STRPTR formatString,...);
  62. static BOOL ComposeName(BPTR ObjLock, char *NameBuffer, LONG *FileSize);
  63.  
  64.  
  65.  
  66. /**********************************************************************/
  67. /*                           Library bases                            */
  68. /**********************************************************************/
  69. struct    DosLibrary    *DOSBase    = NULL;
  70.  
  71.  
  72.  
  73.  
  74.  
  75. /**********************************************************************/
  76. /*                          The main program                          */
  77. /**********************************************************************/
  78. int __saveds DoUnLock(void)
  79. {
  80.     struct    ExecBase    *SysBase    = *((struct ExecBase **)0x4L);
  81.     struct    Process        *MyProc        = (struct Process *)SysBase->ThisTask;
  82.     struct    RDArgs        *RDArgs;
  83.     BPTR            OutHandle;
  84.     APTR            *Args,
  85.                 *OldWindow    = NULL;
  86.     char            *Pattern,
  87.                 *NameBuffer,
  88.                 *SpareBuffer,
  89.                 **FromPtr;
  90.     BOOL            Error        = TRUE,
  91.                 ShowMode;
  92.  
  93.  
  94.         // Ignore startup from WB
  95.  
  96.     if(!(MyProc->pr_CLI))
  97.     {
  98.         struct    Message    *MyMsg;
  99.  
  100.         WaitPort(&MyProc->pr_MsgPort);
  101.         MyMsg = GetMsg(&MyProc->pr_MsgPort);
  102.         Disable();
  103.         ReplyMsg(MyMsg);
  104.         return(10);
  105.     }
  106.  
  107.         // Do the wild thing
  108.  
  109.     if((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 37)))
  110.     {
  111.         OutHandle    = Output();
  112.  
  113.  
  114.             // Allocate buffers
  115.  
  116.         if((Pattern = AllocVec(1024, MEMF_CLEAR)) && (NameBuffer = AllocVec(1024, MEMF_CLEAR)) && (SpareBuffer = AllocVec(1024, MEMF_CLEAR)))
  117.         {
  118.                 // Get buffer for ReadArgs()
  119.  
  120.             if((Args = AllocVec((LAST_ARG * sizeof(ULONG)), MEMF_CLEAR)))
  121.             {
  122.                     // Parse commandline
  123.  
  124.                 if((RDArgs = ReadArgs((char *)Template, (LONG *)Args, NULL)))
  125.                 {
  126.                     Error    = FALSE;
  127.  
  128.                         // Show lock(s)?
  129.  
  130.                     ShowMode    = (BOOL)Args[SHOW_ARG];
  131.  
  132.                         // No object supplied?
  133.                         // Try to show locks
  134.  
  135.                     if(!Args[OBJECT_ARG])
  136.                         UnLockEntry(NULL, NameBuffer, SpareBuffer, TRUE, &Error);
  137.                     else
  138.                     {
  139.                         FromPtr    = (char **)Args[OBJECT_ARG];
  140.  
  141.                             // Loop through dirs
  142.  
  143.                         while(*FromPtr && !Error)
  144.                         {
  145.                             char        *NamePtr;
  146.  
  147.                             NamePtr        = *FromPtr;
  148.  
  149.  
  150.                             if(CheckSignal(SIGBREAKF_CTRL_C))
  151.                             {
  152.                                 FPuts(OutHandle, "\nUnLock: ^C...\n\n");
  153.                                 break;
  154.                             }
  155.  
  156.  
  157.                                 // No Pattern found and no absolute path?
  158.                                 // This is within the current directory
  159.  
  160.                             if(!ParsePatternNoCase(*FromPtr, Pattern, 1024) && !strchr(*FromPtr, ':'))
  161.                             {
  162.                                 BPTR    TestLock;
  163.  
  164.                                     // Try to lock object
  165.  
  166.                                 if((TestLock = Lock(*FromPtr, ACCESS_READ)))
  167.                                 {
  168.                                     if(ComposeName(TestLock, NameBuffer, NULL))
  169.                                         NamePtr    = NameBuffer;
  170.                                     UnLock(TestLock);
  171.                                 }
  172.                             }
  173.  
  174.  
  175.                                 // Create Pattern
  176.                                 // ...and try to unlock
  177.  
  178.                             if(ParsePatternNoCase(NamePtr, Pattern, 1024) != -1)
  179.                             {
  180.                                 ULONG    NumUnlocked;
  181.  
  182.                                 if(!ShowMode)
  183.                                 {
  184.                                     Write(OutHandle, NamePtr, strlen(NamePtr));
  185.                                     Write(OutHandle, "... ", 3);
  186.                                 }
  187.  
  188.                                     // Try to unlock first instance...
  189.  
  190.                                 if((NumUnlocked = UnLockEntry(Pattern, NameBuffer, SpareBuffer, ShowMode, &Error)))
  191.                                 {
  192.                                         // Unlocked more than once?
  193.  
  194.                                     if(NumUnlocked > 1)
  195.                                     {
  196.                                         SPrintF(NameBuffer, "%ld times unlocked\n", NumUnlocked);
  197.                                         FPuts(OutHandle, NameBuffer);
  198.                                     }
  199.                                     else
  200.                                         FPuts(OutHandle, "unlocked\n");
  201.                                 }
  202.                                 else
  203.                                 {
  204.                                     if(!ShowMode)
  205.                                         FPuts(OutHandle, "not unlocked; wasn`t locked\n");
  206.                                 }
  207.                             }
  208.                             else
  209.                                 PrintFault(IoErr(), "\nUnLock ");
  210.  
  211.                                 // Next directory
  212.  
  213.                             FromPtr++;
  214.                         }
  215.                     }
  216.  
  217.                     FreeArgs(RDArgs);
  218.                 }
  219.                 else
  220.                     PrintFault(IoErr(), "\nUnLock ");
  221.  
  222.                     // Free Argument Buffer
  223.  
  224.                 FreeVec(Args);
  225.             }
  226.             else
  227.                 PrintFault(ERROR_NO_FREE_STORE, "\nUnLock ");
  228.         }
  229.         else
  230.             PrintFault(ERROR_NO_FREE_STORE, "\nUnLock ");
  231.  
  232.  
  233.         if(Pattern)
  234.             FreeVec(Pattern);
  235.  
  236.         if(NameBuffer)
  237.             FreeVec(NameBuffer);
  238.  
  239.         if(SpareBuffer)
  240.             FreeVec(SpareBuffer);
  241.  
  242.  
  243.             // Close DOSLibrary
  244.  
  245.         CloseLibrary((struct Library *)DOSBase);
  246.     }
  247.  
  248.         // Restore old window pointer (if any)
  249.  
  250.     if(OldWindow)
  251.         MyProc->pr_WindowPtr    = OldWindow;
  252.  
  253.  
  254.         // Depending on this flag return appropriate return code
  255.  
  256.     if(Error)
  257.         return(0);
  258.     else
  259.         return(10);
  260. }
  261.  
  262.  
  263.  
  264.  
  265.  
  266. /**********************************************************************/
  267. /*                         My special sprintf                         */
  268. /**********************************************************************/
  269. static void __stdargs SPrintF(STRPTR buffer, STRPTR formatString,...)
  270. {
  271.     va_list varArgs;
  272.     va_start(varArgs,formatString);
  273.     RawDoFmt(formatString,varArgs,(void (*)())(void (*))"\x16\xC0\x4E\x75",buffer);
  274.     va_end(varArgs);
  275. }
  276.  
  277.  
  278.  
  279.  
  280.  
  281. /**********************************************************************/
  282. /*                          Unlock an entry                           */
  283. /**********************************************************************/
  284. static ULONG UnLockEntry(char *Pattern, char *NameBuffer, char *SpareBuffer, BOOL Show, BOOL *Error)
  285. {
  286.     struct    DosList                *DList;
  287.     BPTR                    OutHandle    = Output();
  288.     ULONG                    Num        = 0;
  289.     BOOL                    Breaked        = FALSE;
  290.  
  291.  
  292.         // Get pointer to DosList
  293.  
  294.     if((DList = LockDosList(LDF_VOLUMES|LDF_READ)))
  295.     {
  296.         char            *NamePtr;
  297.         BPTR            TestLock,
  298.                     LoopLock,
  299.                     OldLock;
  300.  
  301.             // Print header
  302.  
  303.         if(Show)
  304.         {
  305.             FPuts(OutHandle, "Lock                                 Type Mode  Size       Address\n");
  306.             FPuts(OutHandle, "------------------------------------------------------------------\n");
  307.         }
  308.  
  309.  
  310.             // Loop through list
  311.  
  312.         while((DList = NextDosEntry(DList, LDF_VOLUMES|LDF_READ)))
  313.         {
  314.             memset(NameBuffer, 0, 1024);
  315.  
  316.                 // Create name of volume
  317.  
  318.             NamePtr    = BADDR(DList->dol_Name);
  319.             strncpy(NameBuffer, (NamePtr + 1), *NamePtr);
  320.             strcat(NameBuffer, ":");
  321.  
  322.  
  323.                 // Get lock on volume
  324.  
  325.             if((TestLock = Lock(NameBuffer, ACCESS_READ)))
  326.             {
  327.                     // Start with this first lock
  328.  
  329.                 LoopLock    = OldLock    = TestLock;
  330.  
  331.                     // Loop through all locks on this device
  332.  
  333.                 while(LoopLock && !Breaked)
  334.                 {
  335.                     LONG    FileSize    = -1;
  336.                     BOOL    SkipNext;
  337.  
  338.                     SkipNext    = FALSE;
  339.  
  340.  
  341.                         // Check for control-C
  342.  
  343.                     if(CheckSignal(SIGBREAKF_CTRL_C))
  344.                     {
  345.                         Breaked    = TRUE;
  346.                         break;
  347.                     }
  348.  
  349.                         // Compose file/dir name
  350.  
  351.                     if(ComposeName(LoopLock, NameBuffer, &FileSize))
  352.                     {
  353.                             // Write information about lock
  354.  
  355.                         if(Show)
  356.                         {
  357.                             BOOL    DoShow    = TRUE;
  358.  
  359.                             if(Pattern)
  360.                             {
  361.                                 if(!MatchPatternNoCase(Pattern, NameBuffer))
  362.                                     DoShow    = FALSE;
  363.                             }
  364.  
  365.                             if(DoShow)
  366.                             {
  367.                                 if(FileSize != -1)
  368.                                     SPrintF(SpareBuffer, "%-36.36s FILE %s %8.8ld %8.8lx\n", NameBuffer, (((struct FileLock *)BADDR(LoopLock))->fl_Access == ACCESS_READ) ? "READ " : "WRITE", FileSize, BADDR(LoopLock));
  369.                                 else
  370.                                     SPrintF(SpareBuffer, "%-36.36s DIR  %s -------- %8.8lx\n", NameBuffer, (((struct FileLock *)BADDR(LoopLock))->fl_Access == ACCESS_READ) ? "READ " : "WRITE", BADDR(LoopLock));
  371.  
  372.                                 FPuts(OutHandle, SpareBuffer);
  373.                                 Num++;
  374.                             }
  375.                         }
  376.                         else
  377.                         {
  378.                                 // This one to unlock?
  379.  
  380.                             if(MatchPatternNoCase(Pattern, NameBuffer))
  381.                             {
  382.                                 BPTR        UnLocking    = LoopLock;
  383.  
  384.                                 LoopLock    = (BPTR)((struct FileLock *)BADDR(LoopLock))->fl_Link;
  385.                                 SkipNext    = TRUE;
  386.  
  387.                                 Num++;
  388.  
  389.                                 UnLock(UnLocking);
  390.                             }
  391.                         }
  392.                     }
  393.  
  394.                     if(!SkipNext)
  395.                         LoopLock    = (BPTR)((struct FileLock *)BADDR(LoopLock))->fl_Link;
  396.  
  397.                     if(LoopLock == OldLock)
  398.                         break;
  399.                 }
  400.  
  401.                     // Unlock volume
  402.  
  403.                 UnLock(TestLock);
  404.             }
  405.         }
  406.  
  407.             // Unlock DOSList
  408.  
  409.         UnLockDosList(LDF_VOLUMES|LDF_READ);
  410.     }
  411.     else
  412.         FPuts(OutHandle, "\nUnLock : Couldn`t lock DosList\n");
  413.  
  414.  
  415.     if(!Breaked)
  416.     {
  417.             // Display how many patterns were found
  418.  
  419.         if(Show)
  420.         {
  421.             if(Num > 1)
  422.             {
  423.                 SPrintF(SpareBuffer, "\n%ld locks found\n\n", Num);
  424.                 FPuts(OutHandle, SpareBuffer);
  425.             }
  426.             else if(Num == 1)
  427.                 FPuts(OutHandle, "\nOne lock found\n\n");
  428.             else
  429.                 FPuts(OutHandle, "\nNo lock found\n\n");
  430.  
  431.             return(0);
  432.         }
  433.  
  434.         return(Num);
  435.     }
  436.     else
  437.     {
  438.         *Error    = TRUE;
  439.         FPuts(OutHandle, "\nUnLock: ^C...\n\n");
  440.     }
  441.  
  442.     return(0);
  443. }
  444.  
  445.  
  446.  
  447.  
  448.  
  449. /**********************************************************************/
  450. /*                  Compose a full name from a lock                   */
  451. /**********************************************************************/
  452. static BOOL ComposeName(BPTR ObjLock, char *NameBuffer, LONG *FileSize)
  453. {
  454.     struct    FileInfoBlock    __aligned    FIB;
  455.     BPTR                    NameLock;
  456.     BOOL                    GoOn    = FALSE;
  457.  
  458.     if((NameLock = DupLock(ObjLock)))
  459.     {
  460.             // Get FileInfo
  461.  
  462.         if(Examine(NameLock, &FIB))
  463.         {
  464.                 // Is it a file?
  465.  
  466.             if(FIB.fib_DirEntryType < 0 && FileSize)
  467.                 *FileSize    = FIB.fib_Size;
  468.         }
  469.  
  470.         GoOn    = NameFromLock(NameLock, NameBuffer, 1024);
  471.  
  472.         UnLock(NameLock);
  473.     }
  474.  
  475.     return(GoOn);
  476. }