home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / disk utilities / backup / backup_restore / backup_src_v3.20.lha / DiskSave.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-28  |  5.6 KB  |  283 lines
  1. /* DiskSave.c */
  2. /* 28 Jan 1996 13:06:28 */
  3.  
  4. #ifndef    BACKUP_INCLUDE
  5. #include "IncludeAll.c"
  6. #endif
  7. #include "Backup.h"
  8. #include "Backup_proto.h"
  9. #include "BackupStrings.h"
  10.  
  11.  
  12. #define    SAVE_LIMIT    (4*1024l*1024l)        /* 4MB: größtes Laufwerk mit DiskSaveInfo */
  13.  
  14.  
  15. /* Info für Restart nach Disk-Schreibfehler */
  16. struct DiskSaveInfo
  17.     {
  18.     BOOL Allocated;
  19.  
  20.     APTR *SaveBuffers;        /* Array SaveBuffers[Cylinders] */
  21.     unsigned long SaveBuffCount;    /* Länge von SaveBuffers */
  22.     unsigned long LastUsedCyl;
  23.  
  24.     BPTR SaveFileHandle;
  25.     char *SaveFileName;
  26.     APTR FileBuffer;
  27.     };
  28.  
  29.  
  30. /* globale Disk-Parameter, aus Backup.c */
  31. extern struct BackupDevInfo globDrvDat;
  32. extern struct BackupOptions myOptions;        /* Einstellungen für die aktuelle Sicherung */
  33.  
  34.  
  35. struct DiskSaveInfo __far SaveDisk;
  36.  
  37.  
  38. unsigned long CreateSaveInfo(unsigned long FreeMemory)
  39. {
  40.     unsigned long n, Capacity;
  41.  
  42.     DeleteSaveInfo();
  43.  
  44.     if (CYLSIZE_TAPE == globDrvDat.CylSize)
  45.         return FreeMemory;
  46.  
  47.     if (!globDrvDat.isTape)
  48.         {
  49.         Capacity = globDrvDat.CylSize * globDrvDat.NumCyls;
  50.  
  51.         if (Capacity < FreeMemory/4)
  52.             {
  53.             /* maximal 1/4 des verfügbaren RAMs nutzen */
  54.             /* Save-Buffer im Speicher */
  55.  
  56.             SaveDisk.SaveBuffCount = globDrvDat.NumCyls;
  57.             SaveDisk.SaveBuffers = calloc(SaveDisk.SaveBuffCount, sizeof(APTR));
  58.             if (SaveDisk.SaveBuffers == NULL)
  59.                 {
  60.                 return FreeMemory;
  61.                 }
  62.  
  63.             for (n=0; n<SaveDisk.SaveBuffCount; n++)
  64.                 {
  65.                 SaveDisk.SaveBuffers[n] = AllocVec(globDrvDat.CylSize, globDrvDat.BufMemType);
  66.                 if (SaveDisk.SaveBuffers[n] == NULL)
  67.                     {
  68.                     DeleteSaveInfo();
  69.                     return FreeMemory;
  70.                     }
  71.                 FreeMemory -= globDrvDat.CylSize;
  72.                 }
  73.             }
  74.         else if (Capacity < SAVE_LIMIT)
  75.             {
  76.             /* Save-Buffer auf Disk */
  77.  
  78.             SaveDisk.FileBuffer = AllocVec(globDrvDat.CylSize, globDrvDat.BufMemType);
  79.             if (SaveDisk.FileBuffer == NULL)
  80.                 {
  81.                 DeleteSaveInfo();
  82.                 return FreeMemory;
  83.                 }
  84.  
  85.             SaveDisk.SaveFileName = tempname(myOptions.bo_DiskSavePrefix);
  86.             if (NULL == SaveDisk.SaveFileName)
  87.                 return FreeMemory;
  88.  
  89.             if (SaveDisk.SaveFileName == NULL
  90.                 || (SaveDisk.SaveFileHandle = Open(SaveDisk.SaveFileName,
  91.                     MODE_NEWFILE)) == NULL)
  92.                 {
  93.                 DeleteSaveInfo();
  94.                 return FreeMemory;
  95.                 }
  96.  
  97.             NameFromFH(SaveDisk.SaveFileHandle, SaveDisk.SaveFileName, FMSIZE);
  98.  
  99.             FreeMemory -= globDrvDat.CylSize;
  100.             }
  101.  
  102.         SaveDisk.LastUsedCyl = 0l;
  103.         SaveDisk.Allocated = TRUE;
  104.         }
  105.  
  106.     return FreeMemory;
  107. }
  108.  
  109.  
  110. void DeleteSaveInfo(void)
  111. {
  112.     if (SaveDisk.SaveFileHandle != NULL)
  113.         {
  114.         Close(SaveDisk.SaveFileHandle);
  115.         SaveDisk.SaveFileHandle = NULL;
  116.  
  117.         DeleteFile(SaveDisk.SaveFileName);
  118.         }
  119.     if (SaveDisk.FileBuffer)
  120.         {
  121.         FreeVec(SaveDisk.FileBuffer);
  122.         SaveDisk.FileBuffer = NULL;
  123.         }
  124.     if (SaveDisk.SaveFileName)
  125.         {
  126.         free(SaveDisk.SaveFileName);
  127.         SaveDisk.SaveFileName = NULL;
  128.         }
  129.  
  130.     if (SaveDisk.SaveBuffers)
  131.         {
  132.         unsigned long n;
  133.  
  134.         for (n=0; n<SaveDisk.SaveBuffCount; n++)
  135.             {
  136.             if (SaveDisk.SaveBuffers[n])
  137.                 {
  138.                 FreeVec(SaveDisk.SaveBuffers[n]);
  139.                 SaveDisk.SaveBuffers[n] = NULL;
  140.                 }
  141.             }
  142.         free(SaveDisk.SaveBuffers);
  143.         SaveDisk.SaveBuffers = NULL;
  144.         }
  145.     SaveDisk.Allocated = FALSE;
  146. }
  147.  
  148.  
  149. void RememberSaveInfo(unsigned long Offset, UBYTE *Data, unsigned long Length)
  150. {
  151.     unsigned long Cyl, CylOffset, WriteLength;
  152.  
  153.     if (!SaveDisk.Allocated)
  154.         return;
  155.  
  156.     Offset -= globDrvDat.FirstCyl * globDrvDat.CylSize;
  157.  
  158.     if (SaveDisk.SaveFileHandle)
  159.         {
  160.         Cyl = Offset / globDrvDat.CylSize;
  161.         SaveDisk.LastUsedCyl = max(SaveDisk.LastUsedCyl, Cyl);
  162.  
  163.         if (Seek(SaveDisk.SaveFileHandle, Offset, OFFSET_BEGINNING) == -1
  164.             || Write(SaveDisk.SaveFileHandle, Data, Length) != Length)
  165.             {
  166.             /* Positionier- oder Schreibfehler */
  167.             PostError(TRUE, MSGPRI_Error, GetString(MSG_REMEMBERSAVE_IOERROR), 
  168.                 "RememberSaveInfo",
  169.                 SaveDisk.SaveFileName, GetIoErrText() );
  170.  
  171.             DeleteSaveInfo();
  172.             }
  173.         }
  174.     else
  175.         {
  176.         while (Length)
  177.             {
  178.             Cyl = Offset / globDrvDat.CylSize;
  179.             CylOffset = Offset % globDrvDat.CylSize;
  180.             WriteLength = min(globDrvDat.CylSize-CylOffset, Length);
  181.  
  182.             if (Cyl > SaveDisk.SaveBuffCount)
  183.                 {
  184.                 alarm(GetString(MSG_INTERNALERROR_CYLRANGE),
  185.                     __FUNC__, Cyl, SaveDisk.SaveBuffCount);
  186.  
  187.                 DeleteSaveInfo();
  188.                 return;
  189.                 }
  190.  
  191.             SaveDisk.LastUsedCyl = max(SaveDisk.LastUsedCyl, Cyl);
  192.  
  193.             CopyMem(Data, ((UBYTE *)SaveDisk.SaveBuffers[Cyl]) + CylOffset,
  194.                     WriteLength);
  195.  
  196.             Data += WriteLength;
  197.             Length -= WriteLength;
  198.             Offset += WriteLength;
  199.             }
  200.         }
  201. }
  202.  
  203.  
  204. void ResetDiskSave(void)
  205. {
  206.     SaveDisk.LastUsedCyl = 0l;
  207. }
  208.  
  209.  
  210. BOOL DiskSaveAvailable(void)
  211. {
  212.     return (BOOL) SaveDisk.Allocated;
  213. }
  214.  
  215.  
  216. APTR RetrieveSaveInfo(unsigned long Cyl)
  217. {
  218.     APTR Result = NULL;
  219.  
  220.     if (Cyl <= SaveDisk.LastUsedCyl)
  221.         {
  222.         if (SaveDisk.SaveFileHandle)
  223.             {
  224.             unsigned long Offset;
  225.  
  226.             Offset = Cyl * globDrvDat.CylSize;
  227.             if (Seek(SaveDisk.SaveFileHandle, Offset, OFFSET_BEGINNING) == -1
  228.                 || Read(SaveDisk.SaveFileHandle, SaveDisk.FileBuffer,
  229.                     globDrvDat.CylSize) != globDrvDat.CylSize)
  230.                 {
  231.                 alarm(GetString(MSG_RETRIEVESAVE_IOERROR),
  232.                     __FUNC__, SaveDisk.SaveFileName,
  233.                     GetIoErrText() );
  234.                 myabort(20);
  235.                 }
  236.  
  237.             Result = SaveDisk.FileBuffer;
  238.             }
  239.         else
  240.             Result = SaveDisk.SaveBuffers[Cyl];
  241.         }
  242.  
  243.     return Result;
  244. }
  245.  
  246.  
  247. BOOL isDiskSaveFile(char *Path, char *FileName)
  248. {
  249.     char FilePath[FMSIZE];
  250.  
  251.     if (SaveDisk.SaveFileHandle == NULL)
  252.         return FALSE;
  253.  
  254.     stccpy(FilePath, Path,  sizeof(FilePath));
  255.     if (!AddPart(FilePath, FileName, sizeof(FilePath)))
  256.         return FALSE;
  257.  
  258.     return (BOOL) (stricmp(FilePath, SaveDisk.SaveFileName) == 0);
  259. }
  260.  
  261.  
  262. char *tempname(const char *prefix)
  263. {
  264.     char *result;
  265.     int randomnumber;
  266.  
  267.     if (prefix == NULL)
  268.         prefix = "t:temp";
  269.  
  270.     result = malloc(strlen(prefix)+5);
  271.     if (NULL == result)
  272.         return NULL;
  273.  
  274.     do    {
  275.         randomnumber = rand() % 10000;        /* nur 4stellig */
  276.         sprintf(result, "%s%04d", prefix, randomnumber);
  277.         } while (access(result, F_OK) == 0);
  278.  
  279.     return result;
  280. }
  281.  
  282.  
  283.