Ejemplo n.º 1
0
        /// <inheritdoc />
        public override byte[] GetBytes()
        {
            int Offset = 0;

            byte[] lnk = new byte[Size];
            Buffer.BlockCopy(base.GetBytes(), 0, lnk, 0, (int)HeaderSize);
            Offset += (int)HeaderSize;

            if ((LinkFlags & LinkFlags.HasLinkTargetIDList) != 0)
            {
                Buffer.BlockCopy(LinkTargetIDList.GetBytes(), 0, lnk, Offset, LinkTargetIDList.IDListSize + 2);
                Offset += LinkTargetIDList.IDListSize + 2;
            }

            if ((LinkFlags & LinkFlags.HasLinkInfo) != 0)
            {
                Buffer.BlockCopy(LinkInfo.GetBytes(), 0, lnk, Offset, (int)LinkInfo.LinkInfoSize);
                Offset += (int)LinkInfo.LinkInfoSize;
            }

            if (StringData != null)
            {
                Buffer.BlockCopy(StringData.GetBytes(), 0, lnk, Offset, (int)StringData.StringDataSize);
                Offset += (int)StringData.StringDataSize;
            }

            Buffer.BlockCopy(ExtraData.GetBytes(), 0, lnk, Offset, (int)ExtraData.ExtraDataSize);
            return(lnk);
        }
Ejemplo n.º 2
0
        public static bool Repair(this LinkTargetIDList obj)
        {
            obj.IDList.Repair();

            var sum = obj.IDList.ItemIDList
                      .Sum(x => x.GetLength()) + TerminalID_Size;

            obj.IDListSize = (ushort)sum;

            return(true);
        }
Ejemplo n.º 3
0
        public static void Check(this LinkTargetIDList obj, List <Exception> errors)
        {
            obj.IDList.Check(errors);

            var sum = obj.IDList.ItemIDList
                      .Where(x => x != null)
                      .Sum(x => x.GetLength()) + TerminalID_Size;

            if (obj.IDListSize != sum)
            {
                errors.Add(new InvalidDataException("IDListSize must match the size of all ItemIDList items combined."));
            }
        }
Ejemplo n.º 4
0
        /// <inheritdoc />
        public override String ToString()
        {
            StringBuilder builder = new StringBuilder();

            builder.Append(base.ToString());

            if ((LinkFlags & LinkFlags.HasLinkTargetIDList) != 0)
            {
                builder.Append(LinkTargetIDList.ToString());
            }
            if ((LinkFlags & LinkFlags.HasLinkInfo) != 0)
            {
                builder.Append(LinkInfo.ToString());
            }
            if (StringData != null)
            {
                builder.Append(StringData.ToString());
            }
            if (ExtraData.ExtraDataSize > 4)
            {
                builder.Append(ExtraData.ToString());
            }
            return(builder.ToString());
        }
Ejemplo n.º 5
0
        public static bool Load(
            [NotNull] this LinkTargetIDList obj,
            BinaryReader reader,
            IOptions options
            )
        {
            var provider = options.Get <ItemIDProvider>();

            obj.IDListSize = reader.ReadUInt16();

            while (true)
            {
                var itemid = provider.Read(reader);

                if (itemid == null)
                {
                    break;
                }

                obj.IDList.ItemIDList.Add(itemid);
            }

            return(true);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Create a ShellLing from a given byte array
        /// </summary>
        /// <param name="ba">The byte array</param>
        /// <returns>A Shortcut object</returns>
        public static new Shortcut FromByteArray(byte[] ba)
        {
            Shortcut lnk = new Shortcut();

            #region SHELL_LINK_HEADER
            ShellLinkHeader Header     = ShellLinkHeader.FromByteArray(ba);
            UInt32          HeaderSize = BitConverter.ToUInt32(ba, 0);
            Boolean         IsUnicode  = (Header.LinkFlags & LinkFlags.IsUnicode) != 0;
            lnk.LinkFlags      = Header.LinkFlags;
            lnk.FileAttributes = Header.FileAttributes;
            lnk.CreationTime   = Header.CreationTime;
            lnk.AccessTime     = Header.AccessTime;
            lnk.WriteTime      = Header.WriteTime;
            lnk.FileSize       = Header.FileSize;
            lnk.IconIndex      = Header.IconIndex;
            lnk.ShowCommand    = Header.ShowCommand;
            lnk.HotKey         = Header.HotKey;
            ba = ba.Skip((int)HeaderSize).ToArray();
            #endregion // SHELL_LINK_HEADER

            #region LINKTARGET_IDLIST
            if ((Header.LinkFlags & LinkFlags.HasLinkTargetIDList) != 0)
            {
                lnk.LinkTargetIDList = LinkTargetIDList.FromByteArray(ba);
                UInt16 IDListSize = BitConverter.ToUInt16(ba, 0);
                ba = ba.Skip(IDListSize + 2).ToArray();
            }
            #endregion // LINKTARGET_IDLIST

            #region LINKINFO
            if ((Header.LinkFlags & LinkFlags.HasLinkInfo) != 0)
            {
                lnk.LinkInfo = LinkInfo.FromByteArray(ba);
                UInt32 LinkInfoSize = BitConverter.ToUInt32(ba, 0);
                ba = ba.Skip((int)LinkInfoSize).ToArray();
            }
            #endregion // LINKINFO

            #region STRING_DATA
            if ((Header.LinkFlags & LinkFlags.HasName) != 0)
            {
                if (lnk.StringData == null)
                {
                    lnk.StringData = new StringData(IsUnicode);
                }

                UInt16 CountCharacters = BitConverter.ToUInt16(ba, 0);
                if (IsUnicode)
                {
                    lnk.StringData.NameString = Encoding.Unicode.GetString(ba.Skip(2).Take(CountCharacters * 2).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters * 2 + 2).ToArray();
                }
                else
                {
                    lnk.StringData.NameString = Encoding.Default.GetString(ba.Skip(2).Take(CountCharacters).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters + 2).ToArray();
                }
            }

            if ((Header.LinkFlags & LinkFlags.HasRelativePath) != 0)
            {
                if (lnk.StringData == null)
                {
                    lnk.StringData = new StringData(IsUnicode);
                }

                UInt16 CountCharacters = BitConverter.ToUInt16(ba, 0);
                if (IsUnicode)
                {
                    lnk.StringData.RelativePath = Encoding.Unicode.GetString(ba.Skip(2).Take(CountCharacters * 2).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters * 2 + 2).ToArray();
                }
                else
                {
                    lnk.StringData.RelativePath = Encoding.Default.GetString(ba.Skip(2).Take(CountCharacters).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters + 2).ToArray();
                }
            }

            if ((Header.LinkFlags & LinkFlags.HasWorkingDir) != 0)
            {
                if (lnk.StringData == null)
                {
                    lnk.StringData = new StringData(IsUnicode);
                }

                UInt16 CountCharacters = BitConverter.ToUInt16(ba, 0);
                if (IsUnicode)
                {
                    lnk.StringData.WorkingDir = Encoding.Unicode.GetString(ba.Skip(2).Take(CountCharacters * 2).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters * 2 + 2).ToArray();
                }
                else
                {
                    lnk.StringData.WorkingDir = Encoding.Default.GetString(ba.Skip(2).Take(CountCharacters).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters + 2).ToArray();
                }
            }

            if ((Header.LinkFlags & LinkFlags.HasArguments) != 0)
            {
                if (lnk.StringData == null)
                {
                    lnk.StringData = new StringData(IsUnicode);
                }

                UInt16 CountCharacters = BitConverter.ToUInt16(ba, 0);
                if (IsUnicode)
                {
                    lnk.StringData.CommandLineArguments = Encoding.Unicode.GetString(ba.Skip(2).Take(CountCharacters * 2).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters * 2 + 2).ToArray();
                }
                else
                {
                    lnk.StringData.CommandLineArguments = Encoding.Default.GetString(ba.Skip(2).Take(CountCharacters).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters + 2).ToArray();
                }
            }

            if ((Header.LinkFlags & LinkFlags.HasIconLocation) != 0)
            {
                if (lnk.StringData == null)
                {
                    lnk.StringData = new StringData(IsUnicode);
                }

                UInt16 CountCharacters = BitConverter.ToUInt16(ba, 0);
                if (IsUnicode)
                {
                    lnk.StringData.IconLocation = Encoding.Unicode.GetString(ba.Skip(2).Take(CountCharacters * 2).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters * 2 + 2).ToArray();
                }
                else
                {
                    lnk.StringData.IconLocation = Encoding.Default.GetString(ba.Skip(2).Take(CountCharacters).ToArray()).TrimEnd(new char[] { (char)0 });
                    ba = ba.Skip(CountCharacters + 2).ToArray();
                }
            }
            #endregion // STRING_DATA

            #region EXTRA_DATA
            if (ba.Length >= 4)
            {
                lnk.ExtraData = ExtraData.FromByteArray(ba);
            }
            #endregion // EXTRA_DATA

            return(lnk);
        }