Exemple #1
0
 /// <summary>
 /// Write IMG archive entry
 /// </summary>
 /// <param name="tempArchive">Temporary IMG archive</param>
 /// <param name="newEntry">New IMG archive entry</param>
 /// <param name="stream">Stream</param>
 private void WriteEntry(IMGArchive tempArchive, IMGArchiveEntry newEntry, Stream stream)
 {
     using (Stream temp_stream = tempArchive.entries[newEntry.FullName.ToLower()].Open())
     {
         byte[] temp_data = new byte[temp_stream.Length];
         temp_stream.Read(temp_data, 0, temp_data.Length);
         stream.Write(temp_data, 0, temp_data.Length);
     }
 }
Exemple #2
0
        /// <summary>
        /// Get IMG archive entry
        /// </summary>
        /// <param name="entryName">Entry name</param>
        /// <returns>IMG archive entry if successful, otherwise "null"</returns>
        public IMGArchiveEntry GetEntry(string entryName)
        {
            IMGArchiveEntry ret = null;

            if (entryName != null)
            {
                string key = entryName.ToLower();
                if (entries.ContainsKey(key))
                {
                    ret = entries[key];
                }
            }
            return(ret);
        }
Exemple #3
0
        /// <summary>
        /// Create IMG archive entry
        /// </summary>
        /// <param name="entryName">Entry name</param>
        /// <returns>IMG archive entry if successful, otherwise "null"</returns>
        public IMGArchiveEntry CreateEntry(string entryName)
        {
            IMGArchiveEntry ret        = null;
            string          entry_name = entryName.Trim();
            bool            proceed    = true;

            foreach (char invalid_path_char in Path.GetInvalidPathChars())
            {
                if (entry_name.Contains(new string(new char[] { invalid_path_char })))
                {
                    proceed = false;
                    break;
                }
            }
            if (proceed)
            {
                string key = entry_name.ToLower();
                if (!(entries.ContainsKey(key)))
                {
                    entries.Add(key, new IMGArchiveEntry(this, stream.Length, 0, entry_name, true));
                }
            }
            return(ret);
        }
Exemple #4
0
 /// <summary>
 /// Commit IMG archive entry
 /// </summary>
 /// <param name="entry">IMG archive entry</param>
 /// <param name="entryStream">IMG archive entry stream</param>
 internal void CommitEntry(IIMGArchiveEntry entry, IIMGArchiveEntryStream entryStream)
 {
     try
     {
         if (AccessMode != EIMGArchiveAccessMode.Read)
         {
             string temporary_img_archive_path = Path.Combine(Path.GetTempPath(), $"{ Guid.NewGuid() }.img");
             if (File.Exists(temporary_img_archive_path))
             {
                 File.Delete(temporary_img_archive_path);
             }
             using (FileStream temporary_img_archive_file_stream = File.Open(temporary_img_archive_path, FileMode.Create))
             {
                 Stream.Seek(0L, SeekOrigin.Begin);
                 Stream.CopyTo(temporary_img_archive_file_stream);
             }
             using (IMGArchive temporary_img_archive = IMGFile.OpenRead(temporary_img_archive_path) as IMGArchive)
             {
                 if (temporary_img_archive != null)
                 {
                     InternalEntries.Clear();
                     Stream.SetLength(0L);
                     using (BinaryWriter stream_binary_writer = new BinaryWriter(Stream, EntryNameEncoding, true))
                     {
                         int entry_count                    = temporary_img_archive.InternalEntries.Values.Count + ((entry == null) ? 0 : (entry.IsNewEntry ? 1 : 0));
                         int first_entry_offset             = ((((entry_count * 32) % 2048) == 0) ? ((entry_count * 32) / 2048) : (((entry_count * 32) / 2048) + 1));
                         int current_entry_offset           = first_entry_offset;
                         List <IMGArchiveEntry> new_entries = new List <IMGArchiveEntry>();
                         Dictionary <string, IIMGArchiveEntry> temporary_entries = new Dictionary <string, IIMGArchiveEntry>(temporary_img_archive.InternalEntries);
                         long missing_byte_count;
                         stream_binary_writer.Write(IMGFile.SupportedIMGArchiveVersion);
                         stream_binary_writer.Write((short)entry_count);
                         if ((entry != null) && entry.IsNewEntry)
                         {
                             temporary_entries.Add(entry.FullName.ToLower(), new IMGArchiveEntry(temporary_img_archive, 0L, (int)(entryStream.Stream.Length), entry.FullName));
                         }
                         foreach (KeyValuePair <string, IIMGArchiveEntry> temporary_entry in temporary_entries)
                         {
                             int    entry_length   = (int)((entry == null) ? (((temporary_entry.Value.Length % 2048L) == 0L) ? (temporary_entry.Value.Length / 2048L) : ((temporary_entry.Value.Length / 2048L) + 1L)) : ((entry.FullName.ToLower() == temporary_entry.Key) ? (((entryStream.Stream.Length % 2048L) == 0L) ? (entryStream.Stream.Length / 2048L) : ((entryStream.Stream.Length / 2048L) + 1)) : (((temporary_entry.Value.Length % 2048L) == 0L) ? (temporary_entry.Value.Length / 2048L) : ((temporary_entry.Value.Length / 2048L) + 1L))));
                             byte[] name_bytes_raw = EntryNameEncoding.GetBytes(temporary_entry.Value.FullName);
                             byte[] name_bytes     = new byte[24];
                             Array.Copy(name_bytes_raw, name_bytes, Math.Min(name_bytes_raw.Length, name_bytes.Length));
                             stream_binary_writer.Write(current_entry_offset);
                             stream_binary_writer.Write((short)entry_length);
                             stream_binary_writer.Write(name_bytes);
                             IMGArchiveEntry new_entry = new IMGArchiveEntry(this, current_entry_offset * 2048, entry_length * 2048, temporary_entry.Value.FullName);
                             new_entries.Add(new_entry);
                             InternalEntries.Add(new_entry.FullName.ToLower(), new_entry);
                             current_entry_offset += entry_length;
                         }
                         foreach (IMGArchiveEntry new_entry in new_entries)
                         {
                             stream_binary_writer.Flush();
                             missing_byte_count = new_entry.Offset - Stream.Length;
                             if (missing_byte_count > 0L)
                             {
                                 stream_binary_writer.Write(new byte[missing_byte_count]);
                             }
                             if (entry != null)
                             {
                                 if (entry.FullName == new_entry.FullName)
                                 {
                                     byte[] data = new byte[entryStream.Stream.Length];
                                     entryStream.Stream.Seek(0L, SeekOrigin.Begin);
                                     entryStream.Stream.Read(data, 0, data.Length);
                                     Stream.Write(data, 0, data.Length);
                                 }
                                 else
                                 {
                                     WriteEntry(temporary_img_archive, new_entry, Stream);
                                 }
                             }
                             else
                             {
                                 WriteEntry(temporary_img_archive, new_entry, Stream);
                             }
                         }
                         stream_binary_writer.Flush();
                         missing_byte_count = current_entry_offset - (Stream.Length / 2048);
                         if (missing_byte_count > 0)
                         {
                             stream_binary_writer.Write(new byte[missing_byte_count]);
                         }
                         stream_binary_writer.Flush();
                     }
                 }
             }
             if (File.Exists(temporary_img_archive_path))
             {
                 File.Delete(temporary_img_archive_path);
             }
         }
     }
     catch (Exception e)
     {
         Console.Error.WriteLine(e);
     }
 }
Exemple #5
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry">IMG archive entry</param>
 /// <param name="buffer">Buffer</param>
 /// <param name="index">Index</param>
 /// <param name="count">Count</param>
 /// <param name="writable">Writable</param>
 /// <param name="publiclyVisible">Publicly visible</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry, byte[] buffer, int index, int count, bool writable, bool publiclyVisible) : base(buffer, index, count, writable, publiclyVisible)
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #6
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry">IMG archive entry</param>
 /// <param name="buffer">Buffer</param>
 /// <param name="index">Index</param>
 /// <param name="count">Count</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry, byte[] buffer, int index, int count) : base(buffer, index, count)
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #7
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry">IMG archive entry</param>
 /// <param name="buffer">Buffer</param>
 /// <param name="writable">Writable</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry, byte[] buffer, bool writable) : base(buffer, writable)
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #8
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry">IMG archive entry</param>
 /// <param name="capacity">Capacity</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry, int capacity) : base(capacity)
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #9
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry"></param>
 /// <param name="buffer">Buffer</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry, byte[] buffer) : base(buffer)
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #10
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="imgArchiveEntry">IMG archive entry</param>
 public IMGArchiveEntryStream(IMGArchiveEntry imgArchiveEntry) : base()
 {
     this.imgArchiveEntry = imgArchiveEntry;
 }
Exemple #11
0
 /// <summary>
 /// Commit IMG archive entry
 /// </summary>
 /// <param name="entry">IMG archive entry</param>
 /// <param name="stream">IMG archive entry stream</param>
 internal void CommitEntry(IMGArchiveEntry entry, IMGArchiveEntryStream stream)
 {
     try
     {
         if (mode != EIMGArchiveMode.Read)
         {
             string temp_path = Path.GetTempPath() + Guid.NewGuid().ToString() + ".img";
             if (File.Exists(temp_path))
             {
                 File.Delete(temp_path);
             }
             using (FileStream temp_stream = File.Open(temp_path, FileMode.Create))
             {
                 this.stream.Seek(0L, SeekOrigin.Begin);
                 byte[] buffer     = new byte[2048];
                 int    read_bytes = 0;
                 while ((read_bytes = this.stream.Read(buffer, 0, buffer.Length)) > 0)
                 {
                     temp_stream.Write(buffer, 0, read_bytes);
                 }
             }
             using (IMGArchive temp_archive = IMGFile.OpenRead(temp_path))
             {
                 entries.Clear();
                 this.stream.SetLength(0L);
                 int entry_count                    = temp_archive.entries.Values.Count + ((entry == null) ? 0 : (entry.IsNewEntry ? 1 : 0));
                 int first_entry_offset             = ((((entry_count * 32) % 2048) == 0) ? ((entry_count * 32) / 2048) : (((entry_count * 32) / 2048) + 1));
                 int current_entry_offset           = first_entry_offset;
                 List <IMGArchiveEntry> new_entries = new List <IMGArchiveEntry>();
                 byte[] header_bytes                = new byte[] { 0x56, 0x45, 0x52, 0x32, (byte)(entry_count & 0xFF), (byte)((entry_count >> 8) & 0xFF), 0x0, 0x0 };
                 this.stream.Write(header_bytes, 0, header_bytes.Length);
                 Dictionary <string, IMGArchiveEntry> temp_entries = new Dictionary <string, IMGArchiveEntry>(temp_archive.entries);
                 if (entry != null)
                 {
                     if (entry.IsNewEntry)
                     {
                         temp_entries.Add(entry.FullName.ToLower(), new IMGArchiveEntry(temp_archive, 0L, (int)(stream.Length), entry.FullName));
                     }
                 }
                 foreach (KeyValuePair <string, IMGArchiveEntry> temp_entry in temp_entries)
                 {
                     int    entry_length       = (int)((entry == null) ? (((temp_entry.Value.Length % 2048L) == 0L) ? (temp_entry.Value.Length / 2048L) : ((temp_entry.Value.Length / 2048L) + 1L)) : ((entry.FullName.ToLower() == temp_entry.Key) ? (((stream.Length % 2048L) == 0L) ? (stream.Length / 2048L) : ((stream.Length / 2048L) + 1)) : (((temp_entry.Value.Length % 2048L) == 0L) ? (temp_entry.Value.Length / 2048L) : ((temp_entry.Value.Length / 2048L) + 1L))));
                     byte[] entry_offset_bytes = new byte[] { (byte)(current_entry_offset & 0xFF), (byte)((current_entry_offset >> 8) & 0xFF), (byte)((current_entry_offset >> 16) & 0xFF), (byte)((current_entry_offset >> 24) & 0xFF) };
                     byte[] entry_length_bytes = new byte[] { (byte)(entry_length & 0xFF), (byte)((entry_length >> 8) & 0xFF), 0x0, 0x0 };
                     byte[] name_bytes_raw     = entryNameEncoding.GetBytes(temp_entry.Value.FullName);
                     byte[] name_bytes         = new byte[24];
                     Array.Copy(name_bytes_raw, name_bytes, Math.Min(name_bytes_raw.Length, name_bytes.Length));
                     this.stream.Write(entry_offset_bytes, 0, entry_offset_bytes.Length);
                     this.stream.Write(entry_length_bytes, 0, entry_length_bytes.Length);
                     this.stream.Write(name_bytes, 0, name_bytes.Length);
                     IMGArchiveEntry new_entry = new IMGArchiveEntry(this, current_entry_offset * 2048, entry_length * 2048, temp_entry.Value.FullName);
                     new_entries.Add(new_entry);
                     entries.Add(new_entry.FullName.ToLower(), new_entry);
                     current_entry_offset += entry_length;
                 }
                 foreach (IMGArchiveEntry new_entry in new_entries)
                 {
                     while (this.stream.Length < new_entry.Offset)
                     {
                         this.stream.WriteByte(0);
                     }
                     if (entry != null)
                     {
                         if (entry.FullName == new_entry.FullName)
                         {
                             byte[] data = new byte[stream.Length];
                             stream.Seek(0L, SeekOrigin.Begin);
                             stream.Read(data, 0, data.Length);
                             this.stream.Write(data, 0, data.Length);
                         }
                         else
                         {
                             WriteEntry(temp_archive, new_entry, this.stream);
                         }
                     }
                     else
                     {
                         WriteEntry(temp_archive, new_entry, this.stream);
                     }
                 }
                 while ((this.stream.Length / 2048) < current_entry_offset)
                 {
                     this.stream.WriteByte(0);
                 }
             }
             if (File.Exists(temp_path))
             {
                 File.Delete(temp_path);
             }
         }
     }
     catch (Exception e)
     {
         Console.Error.WriteLine(e.Message);
     }
 }