Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

Implement an Autoplay Handler

, 18 Sep 2006 CPOL
Implementing an Autoplay handler in C#.
autoplaydemo_demo.zip
Almdal.RegistryScript.dll
Almdal.SharedPipes.dll
AutoPlayDemo.exe
AutoPlayListener.dll
autoplaydemo_src.zip
AutoPlayDemo
Autoplay.ico
AutoPlayDemo.csproj.user
bin
Properties
Settings.settings
Resources
AutoPlayListener
Autoplay.ico
AutoPlayListener.snk
bin
Properties
Resources
Autoplay.ico
RegistryScript
Almdal.RegistryScript.snk
bin
Properties
SharedPipies
Almdal.SharedPipes.snk
bin
Properties
using System;
using System.Runtime.InteropServices;

namespace Almdal.AutoPlayListener {
	[Flags]
	enum PageProtection : uint {
		NoAccess = 0x01,
		Readonly = 0x02,
		ReadWrite = 0x04,
		WriteCopy = 0x08,
		Execute = 0x10,
		ExecuteRead = 0x20,
		ExecuteReadWrite = 0x40,
		ExecuteWriteCopy = 0x80,
		Guard = 0x100,
		NoCache = 0x200,
		WriteCombine = 0x400,
	}

	enum FileAccess : uint {
		SECTION_QUERY = 0x0001,
		SECTION_MAP_WRITE = 0x0002,
		SECTION_MAP_READ = 0x0004,
		SECTION_MAP_EXECUTE = 0x0008,
		SECTION_EXTEND_SIZE = 0x0010,
		STANDARD_RIGHTS_REQUIRED = 0x000F0000,
		SECTION_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
			SECTION_MAP_WRITE |
			SECTION_MAP_READ |
			SECTION_MAP_EXECUTE |
			SECTION_EXTEND_SIZE,
		FILE_MAP_ALL_ACCESS = SECTION_ALL_ACCESS
	}

	public class SharedMemory : IDisposableImpl {
        #region Memory Mapping Routines
        static IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

       [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr CreateFileMapping(
            IntPtr hFile,                       //  A handle to the file from which to create a mapping object
                                                //  If hFile is INVALID_HANDLE_VALUE, the calling process must 
                                                //  also specify a mapping object size in the dwMaximumSizeHigh 
                                                //  and dwMaximumSizeLow parameters. In this scenario, 
                                                //  CreateFileMapping creates a file mapping object of a specified 
                                                //  size that the operating system paging file backs, instead of by 
                                                //  a named file in the file system.
            IntPtr lpFileMappingAttributes,     //  A pointer to a SECURITY_ATTRIBUTES structure that determines 
                                                //  whether or not a returned handle can be inherited by child 
                                                //  processes.  If lpAttributes is NULL, the handle cannot be inherited.
            PageProtection flProtect,           //  The protection for the file view, when the file is mapped.
            uint dwMaximumSizeHigh,             //  A high-order DWORD for the maximum size of a file mapping object.
            uint dwMaximumSizeLow,              //  A low-order DWORD for the maximum size of a file mapping object.
            string lpName);                     //  A pointer to a null-terminated string that specifies the name of a mapping object

        [DllImport("kernel32.dll")]
        private static extern IntPtr OpenFileMapping(
                FileAccess dwDesiredAccess,     //  Access to the file mapping object
                bool bInheritHandle,            //  If this parameter is TRUE, a process created by the CreateProcess 
                                                //  function can inherit the handle; otherwise, the handle cannot be 
                                                //  inherited
                string lpName);                 //  Pointer to a string that names the file mapping object to be opened. 
                                                //  If there is an open handle to a file mapping object by this name 
                                                //  and the security descriptor on the mapping object does not conflict
                                                //  with the dwDesiredAccess parameter, the open operation succeeds

        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr MapViewOfFile(
            IntPtr hFileMappingObject,          //  A handle to an open handle of a file mapping object
            FileAccess dwDesiredAccess,         //  The type of access to a file mapping object, which ensures the 
                                                //  protection of the pages
            uint dwFileOffsetHigh,              //  A high-order DWORD of the file offset where the view begins.
            uint dwFileOffsetLow,               //  A low-order DWORD of the file offset where the view is begins
            uint dwNumberOfBytesToMap);         //  The number of bytes of a file mapping to map to the view. If this 
                                                //  parameter is 0 (zero), the mapping extends from the specified offset
                                                //  to the end of the section.

        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool UnmapViewOfFile(
            IntPtr lpBaseAddress);              //  Pointer to the base address of the mapped view of a file that is to be 
                                                //  unmapped. This value must be identical to the value returned by a 
                                                //  previous call to the MapViewOfFile.

		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CloseHandle(
			IntPtr hObject);					//	Handle of the File Object
		#endregion

        private string _name;
        private IntPtr _memHandle;

        public SharedMemory(string name) {
            _name = name;
            _memHandle = OpenFileMapping(FileAccess.FILE_MAP_ALL_ACCESS, false, _name);
            if (IntPtr.Zero.Equals(_memHandle) ) {
                throw new Exception("Could not open shared memory file mapping object: LasterrorCode: " +
                                    Marshal.GetLastWin32Error());
            }
        }

        public SharedMemory(string name, uint size) {
            _name = name;
            _memHandle = CreateFileMapping(INVALID_HANDLE_VALUE,     //  Use paging file
                                           IntPtr.Zero,              //  Default security
                                           PageProtection.ReadWrite, //  Read/write access
                                           0,
                                           size,
                                           _name);
            if (IntPtr.Zero.Equals(_memHandle) || INVALID_HANDLE_VALUE.Equals(_memHandle)) {
                throw new Exception("Could not create shared memory file mapping object: LasterrorCode: " +
                                    Marshal.GetLastWin32Error());
            }
        }

        public void WriteString(string str) {
            IntPtr pbuf = MapViewOfFile(_memHandle, FileAccess.FILE_MAP_ALL_ACCESS, 0, 0, 0);
            if (IntPtr.Zero.Equals(_memHandle)) {
                throw new Exception("Unable to Map to shared memory file mapping object: LasterrorCode: " +
                                    Marshal.GetLastWin32Error());
            }
            try {
                Marshal.Copy(str.ToCharArray(), 0, pbuf, str.Length);
                IntPtr bufPos = new IntPtr((int)pbuf + (sizeof(char)*str.Length));
                Marshal.Copy(new char[] { '\0' }, 0, bufPos, 1);
            } finally {
                UnmapViewOfFile(pbuf);
            }
        }

        public string ReadString() {
            IntPtr pbuf = MapViewOfFile(_memHandle, FileAccess.FILE_MAP_ALL_ACCESS, 0, 0, 0);
            if (IntPtr.Zero.Equals(_memHandle)) {
                throw new Exception("Unable to Map to shared memory file mapping object: LasterrorCode: " +
                                    Marshal.GetLastWin32Error());
            }
            try {
                return Marshal.PtrToStringUni(pbuf);
            } finally {
                UnmapViewOfFile(pbuf);
            }
        }

        protected override void DisposeUnmanagedResources() {
            CloseHandle(_memHandle);
            _memHandle = IntPtr.Zero;
        }
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Tim Almdal

Canada Canada
No Biography provided

| Advertise | Privacy | Mobile
Web01 | 2.8.141022.2 | Last Updated 18 Sep 2006
Article Copyright 2006 by Tim Almdal
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid