Add missing files for OPS [SD:717473]

src/Microsoft.PowerShell.Commands.Management/commands/management/TimeZoneCommands.cs

@@ -0,0 +1,862 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Management.Automation;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.PowerShell.Commands
+{
+    /// <summary>
+    /// A cmdlet to retrieve time zone information.
+    /// </summary>
+    [Cmdlet(VerbsCommon.Get, "TimeZone", DefaultParameterSetName = "Name",
+        HelpUri = "http://go.microsoft.com/fwlink/?LinkId=799468")]
+    [Alias("gtz")]
+    public class GetTimeZoneCommand : PSCmdlet
+    {
+        #region Parameters
+
+        /// <summary>
+        /// A list of the local time zone ids that the cmdlet should look up.
+        /// </summary>
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, ParameterSetName = "Id")]
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public string[] Id { get; set; }
+
+        /// <summary>
+        /// Specifies that the cmdlet should produce a collection of the 
+        /// TimeZoneInfo objects that are available on the system.
+        /// </summary>
+        [Parameter(Mandatory = true, ParameterSetName = "ListAvailable")]
+        public SwitchParameter ListAvailable { get; set; }
+
+        /// <summary>
+        /// A list of the local time zone names that the cmdlet should look up.
+        /// </summary>
+        [Parameter(Position = 0, ValueFromPipeline = true, ParameterSetName = "Name")]
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public string[] Name { get; set; }
+
+        #endregion Parameters
+
+        /// <summary>
+        /// Implementation of the ProcessRecord method for Get-TimeZone
+        /// </summary>
+        protected override void ProcessRecord()
+        {
+            // make sure we've got the latest time zone settings
+            TimeZoneHelper.ClearCachedData();
+
+            if (this.ParameterSetName.Equals("ListAvailable", StringComparison.OrdinalIgnoreCase))
+            {
+                // output the list of all available time zones
+                WriteObject(TimeZoneInfo.GetSystemTimeZones(), true);
+            }
+            else if (this.ParameterSetName.Equals("Id", StringComparison.OrdinalIgnoreCase))
+            {
+                // lookup each time zone id
+                foreach (string tzid in Id)
+                {
+                    try
+                    {
+                        WriteObject(TimeZoneInfo.FindSystemTimeZoneById(tzid));
+                    }
+#if CORECLR
+                    // TimeZoneNotFoundException is thrown by TimeZoneInfo, but not
+                    // publicly visible (so can't be caught), so for now we're catching
+                    // the parent exception time. This should be removed once the more
+                    // specific exception is available.
+                    catch (Exception e)
+#else
+                    catch (TimeZoneNotFoundException e)
+#endif
+                    {
+                        WriteError(new ErrorRecord(e, TimeZoneHelper.TimeZoneNotFoundError,
+                            ErrorCategory.InvalidArgument, "Id"));
+                    }
+                }
+            }
+            else // ParameterSetName == "Name"
+            {
+                if (null != Name)
+                {
+                    // lookup each time zone name (or wildcard pattern)
+                    foreach (string tzname in Name)
+                    {
+                        TimeZoneInfo[] timeZones = TimeZoneHelper.LookupSystemTimeZoneInfoByName(tzname);
+                        if (0 < timeZones.Length)
+                        {
+                            // manually process each object in the array, so if there is only a single
+                            // entry then the returned type is TimeZoneInfo and not TimeZoneInfo[], and
+                            // it can be pipelined to Set-TimeZone more easily
+                            foreach (TimeZoneInfo timeZone in timeZones)
+                            {
+                                WriteObject(timeZone);
+                            }
+                        }
+                        else
+                        {
+                            string message = string.Format(CultureInfo.InvariantCulture,
+                                TimeZoneResources.TimeZoneNameNotFound, tzname);
+#if CORECLR
+                        // Because .NET Core does not currently expose the TimeZoneNotFoundException
+                        // we need to throw the more generic parent exception class for the time being.
+                        // This should be removed once the correct exception class is available.
+                        Exception e = new Exception(message);
+#else
+                            Exception e = new TimeZoneNotFoundException(message);
+#endif
+                            WriteError(new ErrorRecord(e, TimeZoneHelper.TimeZoneNotFoundError,
+                                ErrorCategory.InvalidArgument, "Name"));
+                        }
+                    }
+                }
+                else
+                {
+                    // return the current system local time zone
+                    WriteObject(TimeZoneInfo.Local);
+                }
+            }
+        }
+    }
+
+
+    /// <summary>
+    /// A cmdlet to set the system's local time zone.
+    /// </summary>
+    [Cmdlet(VerbsCommon.Set, "TimeZone",
+        SupportsShouldProcess = true,
+        DefaultParameterSetName = "Name", 
+        HelpUri = "http://go.microsoft.com/fwlink/?LinkId=799469")]
+    [Alias("stz")]
+    public class SetTimeZoneCommand : PSCmdlet
+    {
+        #region string constants
+
+        private const string TimeZoneTarget = "Local System";
+
+        #endregion string constants
+
+        #region Parameters
+
+        /// <summary>
+        /// The name of the local time zone that the system should use.
+        /// </summary>
+        [Parameter(Mandatory = true, ParameterSetName = "Id", ValueFromPipelineByPropertyName = true)]
+        public string Id { get; set; }
+
+        /// <summary>
+        /// A TimeZoneInfo object identifying the local time zone that the system should use.
+        /// </summary>
+        [Parameter(Mandatory = true, Position = 0, ParameterSetName = "InputObject", ValueFromPipeline = true)]
+        public TimeZoneInfo InputObject { get; set; }
+
+        /// <summary>
+        /// The name of the local time zone that the system should use.
+        /// </summary>
+        [Parameter(Mandatory = true, Position = 0, ParameterSetName = "Name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Request return of the new local time zone as a TimeZoneInfo object
+        /// </summary>
+        [Parameter]
+        public SwitchParameter PassThru { get; set; }
+
+        #endregion Parameters
+
+        /// <summary>
+        /// Implementation of the ProcessRecord method for Get-TimeZone
+        /// </summary>
+        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "Since Name is not a parameter of this method, it confuses FXCop. It is the appropriate value for the exception.")]
+        protected override void ProcessRecord()
+        {
+            // make sure we've got fresh data, in case the requested time zone was added
+            // to the system (registry) after our process was started
+            TimeZoneHelper.ClearCachedData();
+
+            // acquire a TimeZoneInfo if one wasn't supplied.
+            if (this.ParameterSetName.Equals("Id", StringComparison.OrdinalIgnoreCase))
+            {
+                try
+                {
+                    InputObject = TimeZoneInfo.FindSystemTimeZoneById(Id);
+                }
+#if CORECLR
+                // TimeZoneNotFoundException is thrown by TimeZoneInfo, but not
+                // publicly visible (so can't be caught), so for now we're catching
+                // the parent exception time. This should be removed once the more
+                // specific exception is available.
+                catch (Exception e)
+#else
+                catch (TimeZoneNotFoundException e)
+#endif
+                {
+                    ThrowTerminatingError(new ErrorRecord(
+                        e,
+                        TimeZoneHelper.TimeZoneNotFoundError,
+                        ErrorCategory.InvalidArgument,
+                        "Id"));
+                }
+            }
+            else if (this.ParameterSetName.Equals("Name", StringComparison.OrdinalIgnoreCase))
+            {
+                // lookup the time zone name and make sure we have one (and only one) match
+                TimeZoneInfo[] timeZones = TimeZoneHelper.LookupSystemTimeZoneInfoByName(Name);
+                if (0 == timeZones.Length)
+                {
+                    string message = string.Format(CultureInfo.InvariantCulture,
+                        TimeZoneResources.TimeZoneNameNotFound, Name);
+#if CORECLR
+                    // Because .NET Core does not currently expose the TimeZoneNotFoundException
+                    // we need to throw the more generic parent exception class for the time being.
+                    // This should be removed once the correct exception class is available.
+                    Exception e = new Exception(message);
+#else
+                    Exception e = new TimeZoneNotFoundException(message);
+#endif
+                    ThrowTerminatingError(new ErrorRecord(e,
+                        TimeZoneHelper.TimeZoneNotFoundError,
+                        ErrorCategory.InvalidArgument,
+                        "Name"));
+                }
+                else if (1 < timeZones.Length)
+                {
+                    string message = string.Format(CultureInfo.InvariantCulture,
+                        TimeZoneResources.MultipleMatchingTimeZones, Name);
+                    ThrowTerminatingError(new ErrorRecord(
+                            new PSArgumentException(message, "Name"),
+                            TimeZoneHelper.MultipleMatchingTimeZonesError,
+                            ErrorCategory.InvalidArgument,
+                            "Name"));
+                }
+                else
+                {
+                    InputObject = timeZones[0];
+                }
+            }
+            else // ParameterSetName == "InputObject"
+            {
+                try
+                {
+                    // a TimeZoneInfo object was supplied, so use it to make sure we can find
+                    // a backing system time zone, otherwise it's an error condition
+                    InputObject = TimeZoneInfo.FindSystemTimeZoneById(InputObject.Id);
+                }
+#if CORECLR
+                // TimeZoneNotFoundException is thrown by TimeZoneInfo, but not
+                // publicly visible (so can't be caught), so for now we're catching
+                // the parent exception time. This should be removed once the more
+                // specific exception is available.
+                catch (Exception e)
+#else
+                catch (TimeZoneNotFoundException e)
+#endif
+                {
+                    ThrowTerminatingError(new ErrorRecord(
+                        e,
+                        TimeZoneHelper.TimeZoneNotFoundError,
+                        ErrorCategory.InvalidArgument,
+                        "InputObject"));
+                }
+            }
+
+            if (ShouldProcess(TimeZoneTarget))
+            {
+                bool acquireAccess = false;
+                try
+                {
+                    // check to see if permission to set the time zone is already enabled for this process
+                    if (!HasAccess)
+                    {
+                        // acquire permissions to set the timezone
+                        SetAccessToken(true);
+                        acquireAccess = true;
+                    }
+                }
+                catch (Win32Exception e)
+                {
+                    ThrowTerminatingError(new ErrorRecord(e,
+                        TimeZoneHelper.InsufficientPermissionsError,
+                        ErrorCategory.PermissionDenied, null));
+                }
+
+                try
+                {
+                    // construct and populate a new DYNAMIC_TIME_ZONE_INFORMATION structure
+                    NativeMethods.DYNAMIC_TIME_ZONE_INFORMATION dtzi = new NativeMethods.DYNAMIC_TIME_ZONE_INFORMATION();
+                    dtzi.Bias -= (int)InputObject.BaseUtcOffset.TotalMinutes;
+                    dtzi.StandardName = InputObject.StandardName;
+                    dtzi.DaylightName = InputObject.DaylightName;
+                    dtzi.TimeZoneKeyName = InputObject.Id;
+
+                    // Request time zone transition information for the current year
+                    NativeMethods.TIME_ZONE_INFORMATION tzi = new NativeMethods.TIME_ZONE_INFORMATION();
+                    if (!NativeMethods.GetTimeZoneInformationForYear((ushort)DateTime.Now.Year, ref dtzi, ref tzi))
+                    {
+                        ThrowWin32Error();
+                    }
+
+                    // copy over the transition times
+                    dtzi.StandardBias = tzi.StandardBias;
+                    dtzi.StandardDate = tzi.StandardDate;
+                    dtzi.DaylightBias = tzi.DaylightBias;
+                    dtzi.DaylightDate = tzi.DaylightDate;
+
+                    // set the new local time zone for the system
+                    if (!NativeMethods.SetDynamicTimeZoneInformation(ref dtzi))
+                    {
+                        ThrowWin32Error();
+                    }
+
+#if !CORECLR
+                    // broadcast a WM_SETTINGCHANGE notification message to all top-level windows so that they
+                    // know to update their notion of the current system time (and time zone) if applicable
+                    int result = 0;
+                    NativeMethods.SendMessageTimeout((IntPtr)NativeMethods.HWND_BROADCAST, NativeMethods.WM_SETTINGCHANGE,
+                        (IntPtr)0, "intl", NativeMethods.SMTO_ABORTIFHUNG, 5000, ref result);
+#endif
+
+                    // clear the time zone data or this PowerShell session
+                    // will not recognize the new time zone settings
+                    TimeZoneHelper.ClearCachedData();
+
+                    if (PassThru.IsPresent)
+                    {
+                        // return the TimeZoneInfo object for the (new) current local time zone
+                        WriteObject(TimeZoneInfo.Local);
+                    }
+                }
+                catch (Win32Exception e)
+                {
+                    ThrowTerminatingError(new ErrorRecord(e,
+                        TimeZoneHelper.SetTimeZoneFailedError,
+                        ErrorCategory.FromStdErr, null));
+                }
+                finally
+                {
+                    if (acquireAccess)
+                    {
+                        // reset the permissions
+                        SetAccessToken(false);
+                    }
+                }
+            }
+            else
+            {
+                if (PassThru.IsPresent)
+                {
+                    // show the user the time zone settings that would have been used.
+                    WriteObject(InputObject);
+                }
+            }
+        }
+
+        #region Helper functions
+
+        /// <summary>
+        /// True if the current process has access to change the time zone setting.
+        /// </summary>
+        protected bool HasAccess
+        {
+            get
+            {
+                bool hasAccess = false;
+
+                // open the access token for the current process
+                IntPtr hToken = IntPtr.Zero;
+                IntPtr hProcess = NativeMethods.GetCurrentProcess();
+                if (!NativeMethods.OpenProcessToken(hProcess,
+                    NativeMethods.TOKEN_ADJUST_PRIVILEGES | NativeMethods.TOKEN_QUERY, ref hToken))
+                {
+                    ThrowWin32Error();
+                }
+
+                try
+                {
+                    // setup the privileges being checked
+                    NativeMethods.PRIVILEGE_SET ps = new NativeMethods.PRIVILEGE_SET()
+                    {
+                        PrivilegeCount = 1,
+                        Control = 1,
+                        Luid = 0,
+                        Attributes = NativeMethods.SE_PRIVILEGE_ENABLED,
+                    };
+
+                    // lookup the Luid of the SeTimeZonePrivilege
+                    if (!NativeMethods.LookupPrivilegeValue(null, NativeMethods.SE_TIME_ZONE_NAME, ref ps.Luid))
+                    {
+                        ThrowWin32Error();
+                    }
+
+                    // set the privilege for the open access token
+                    if (!NativeMethods.PrivilegeCheck(hToken, ref ps, ref hasAccess))
+                    {
+                        ThrowWin32Error();
+                    }
+                }
+                finally
+                {
+                    NativeMethods.CloseHandle(hToken);
+                }
+
+                return (hasAccess);
+            }
+        }
+
+        /// <summary>
+        /// Set the SeTimeZonePrivilege, which controls access to the SetDynamicTimeZoneInformation API
+        /// </summary>
+        /// <param name="enable">Set to true to enable (or false to disable) the privilege.</param>
+        protected void SetAccessToken(bool enable)
+        {
+            // open the access token for the current process
+            IntPtr hToken = IntPtr.Zero;
+            IntPtr hProcess = NativeMethods.GetCurrentProcess();
+            if (!NativeMethods.OpenProcessToken(hProcess,
+                NativeMethods.TOKEN_ADJUST_PRIVILEGES | NativeMethods.TOKEN_QUERY, ref hToken))
+            {
+                ThrowWin32Error();
+            }
+
+            try
+            {
+                // setup the privileges being requested
+                NativeMethods.TOKEN_PRIVILEGES tp = new NativeMethods.TOKEN_PRIVILEGES()
+                {
+                    PrivilegeCount = 1,
+                    Luid = 0,
+                    Attributes = (enable ? NativeMethods.SE_PRIVILEGE_ENABLED : 0),
+                };
+
+                // lookup the Luid of the SeTimeZonePrivilege
+                if (!NativeMethods.LookupPrivilegeValue(null, NativeMethods.SE_TIME_ZONE_NAME, ref tp.Luid))
+                {
+                    ThrowWin32Error();
+                }
+
+                // set the privilege for the open access token
+                if (!NativeMethods.AdjustTokenPrivileges(hToken, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero))
+                {
+                    ThrowWin32Error();
+                }
+            }
+            finally
+            {
+                NativeMethods.CloseHandle(hToken);
+            }
+        }
+
+        /// <summary>
+        /// Get the Win32 error code from GetLastError and throw an exception.
+        /// </summary>
+        protected void ThrowWin32Error()
+        {
+            int error = Marshal.GetLastWin32Error();
+            throw new Win32Exception(error);
+        }
+
+        #endregion Helper functions
+
+        #region Win32 interop helper
+
+        internal class NativeMethods
+        {
+            /// <summary>
+            /// Private constructor to prevent instantiation
+            /// </summary>
+            private NativeMethods()
+            {
+            }
+
+            #region Native DLL locations
+
+#if CORECLR
+            private const string SetDynamicTimeZoneApiDllName = "api-ms-win-core-timezone-l1-1-0.dll";
+            private const string GetTimeZoneInformationForYearApiDllName = "api-ms-win-core-timezone-l1-1-0.dll";
+            private const string GetCurrentProcessApiDllName = "api-ms-win-downlevel-kernel32-l1-1-0.dll";
+            private const string OpenProcessTokenApiDllName = "api-ms-win-downlevel-advapi32-l1-1-1.dll";
+            private const string LookupPrivilegeTokenApiDllName = "api-ms-win-downlevel-advapi32-l4-1-0.dll";
+            private const string PrivilegeCheckApiDllName = "api-ms-win-downlevel-advapi32-l1-1-1.dll";
+            private const string AdjustTokenPrivilegesApiDllName = "api-ms-win-downlevel-advapi32-l1-1-1.dll";
+            private const string CloseHandleApiDllName = "api-ms-win-downlevel-kernel32-l1-1-0.dll";
+            private const string SendMessageTimeoutApiDllName = "ext-ms-win-rtcore-ntuser-window-ext-l1-1-0.dll";            
+#else
+            private const string SetDynamicTimeZoneApiDllName = "kernel32.dll";
+            private const string GetTimeZoneInformationForYearApiDllName = "kernel32.dll";
+            private const string GetCurrentProcessApiDllName = "kernel32.dll";
+            private const string OpenProcessTokenApiDllName = "advapi32.dll";
+            private const string LookupPrivilegeTokenApiDllName = "advapi32.dll";
+            private const string PrivilegeCheckApiDllName = "advapi32.dll";
+            private const string AdjustTokenPrivilegesApiDllName = "advapi32.dll";
+            private const string CloseHandleApiDllName = "kernel32.dll";
+            private const string SendMessageTimeoutApiDllName = "user32.dll";
+#endif
+
+            #endregion Native DLL locations
+
+            #region Win32 SetDynamicTimeZoneInformation imports
+
+            /// <summary>
+            /// Used to marshal win32 SystemTime structure to managed code layer
+            /// </summary>
+            [StructLayout(LayoutKind.Sequential)]
+            public struct SystemTime
+            {
+                /// <summary>
+                /// The year.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Year;
+                /// <summary>
+                /// The month.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Month;
+                /// <summary>
+                /// The day of the week.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short DayOfWeek;
+                /// <summary>
+                /// The day of the month.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Day;
+                /// <summary>
+                /// The hour.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Hour;
+                /// <summary>
+                /// The minute.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Minute;
+                /// <summary>
+                /// The second.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Second;
+                /// <summary>
+                /// The millisecond.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U2)]
+                public short Milliseconds;
+            }
+
+            /// <summary>
+            /// Used to marshal win32 DYNAMIC_TIME_ZONE_INFORMATION structure to managed code layer
+            /// </summary>
+            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+            public struct DYNAMIC_TIME_ZONE_INFORMATION
+            {
+                /// <summary>
+                /// The current bias for local time translation on this computer, in minutes.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int Bias;
+                /// <summary>
+                /// A description for standard time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]
+                public string StandardName;
+                /// <summary>
+                /// A SystemTime structure that contains a date and local time when the transition from daylight saving time to standard time occurs on this operating system.
+                /// </summary>
+                public SystemTime StandardDate;
+                /// <summary>
+                /// The bias value to be used during local time translations that occur during standard time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int StandardBias;
+                /// <summary>
+                /// A description for daylight saving time (DST).
+                /// </summary>
+                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]
+                public string DaylightName;
+                /// <summary>
+                /// A SystemTime structure that contains a date and local time when the transition from standard time to daylight saving time occurs on this operating system.
+                /// </summary>
+                public SystemTime DaylightDate;
+                /// <summary>
+                /// The bias value to be used during local time translations that occur during daylight saving time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int DaylightBias;
+                /// <summary>
+                /// The name of the time zone registry key on the local computer.
+                /// </summary>
+                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x80)]
+                public string TimeZoneKeyName;
+                /// <summary>
+                /// Indicates whether dynamic daylight saving time is disabled.
+                /// </summary>
+                [MarshalAs(UnmanagedType.U1)]
+                public bool DynamicDaylightTimeDisabled;
+            }
+
+            /// <summary>
+            /// Used to marshal win32 TIME_ZONE_INFORMATION structure to managed code layer
+            /// </summary>
+            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+            public struct TIME_ZONE_INFORMATION
+            {
+                /// <summary>
+                /// The current bias for local time translation on this computer, in minutes.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int Bias;
+                /// <summary>
+                /// A description for standard time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]
+                public string StandardName;
+                /// <summary>
+                /// A SystemTime structure that contains a date and local time when the transition from daylight saving time to standard time occurs on this operating system.
+                /// </summary>
+                public SystemTime StandardDate;
+                /// <summary>
+                /// The bias value to be used during local time translations that occur during standard time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int StandardBias;
+                /// <summary>
+                /// A description for daylight saving time (DST).
+                /// </summary>
+                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 0x20)]
+                public string DaylightName;
+                /// <summary>
+                /// A SystemTime structure that contains a date and local time when the transition from standard time to daylight saving time occurs on this operating system.
+                /// </summary>
+                public SystemTime DaylightDate;
+                /// <summary>
+                /// The bias value to be used during local time translations that occur during daylight saving time.
+                /// </summary>
+                [MarshalAs(UnmanagedType.I4)]
+                public int DaylightBias;
+            }
+
+            /// <summary>
+            /// PInvoke SetDynamicTimeZoneInformation API
+            /// </summary>
+            /// <param name="lpTimeZoneInformation">A DYNAMIC_TIME_ZONE_INFORMATION structure representing the desired local time zone.</param>
+            /// <returns></returns>
+            [DllImport(SetDynamicTimeZoneApiDllName, SetLastError = true)]
+            public static extern bool SetDynamicTimeZoneInformation([In] ref DYNAMIC_TIME_ZONE_INFORMATION lpTimeZoneInformation);
+
+            [DllImport(GetTimeZoneInformationForYearApiDllName, SetLastError = true)]
+            public static extern bool GetTimeZoneInformationForYear([In] ushort wYear, [In] ref DYNAMIC_TIME_ZONE_INFORMATION pdtzi, ref TIME_ZONE_INFORMATION ptzi);
+
+            #endregion Win32 SetDynamicTimeZoneInformation imports
+
+            #region Win32 AdjustTokenPrivilege imports
+
+            /// <summary>
+            /// Definition of TOKEN_QUERY constant from Win32 API
+            /// </summary>
+            public const int TOKEN_QUERY = 0x00000008;
+
+            /// <summary>
+            /// Definition of TOKEN_ADJUST_PRIVILEGES constant from Win32 API
+            /// </summary>
+            public const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
+
+            /// <summary>
+            /// Definition of SE_PRIVILEGE_ENABLED constant from Win32 API
+            /// </summary>
+            public const int SE_PRIVILEGE_ENABLED = 0x00000002;
+
+            /// <summary>
+            /// Definition of SE_TIME_ZONE_NAME constant from Win32 API
+            /// </summary>
+            public const string SE_TIME_ZONE_NAME = "SeTimeZonePrivilege"; //http://msdn.microsoft.com/en-us/library/bb530716(VS.85).aspx
+
+            /// <summary>
+            /// PInvoke GetCurrentProcess API
+            /// </summary>
+            /// <returns></returns>
+            [DllImport(GetCurrentProcessApiDllName, ExactSpelling = true)]
+            public static extern IntPtr GetCurrentProcess();
+
+            /// <summary>
+            /// PInvoke OpenProcessToken API
+            /// </summary>
+            /// <param name="ProcessHandle"></param>
+            /// <param name="DesiredAccess"></param>
+            /// <param name="TokenHandle"></param>
+            /// <returns></returns>
+            [DllImport(OpenProcessTokenApiDllName, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool OpenProcessToken(IntPtr ProcessHandle, int DesiredAccess, ref IntPtr TokenHandle);
+
+            /// <summary>
+            /// PInvoke LookupPrivilegeValue API
+            /// </summary>
+            /// <param name="lpSystemName"></param>
+            /// <param name="lpName"></param>
+            /// <param name="lpLuid"></param>
+            /// <returns></returns>
+            [DllImport(LookupPrivilegeTokenApiDllName, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, ref long lpLuid);
+
+            /// <summary>
+            /// PInvoke PrivilegeCheck API
+            /// </summary>
+            /// <param name="ClientToken"></param>
+            /// <param name="RequiredPrivileges"></param>
+            /// <param name="pfResult"></param>
+            /// <returns></returns>
+            [DllImport(PrivilegeCheckApiDllName, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool PrivilegeCheck(IntPtr ClientToken, ref PRIVILEGE_SET RequiredPrivileges, ref bool pfResult);
+
+
+            /// <summary>
+            /// PInvoke AdjustTokenPrivilege API
+            /// </summary>
+            /// <param name="TokenHandle"></param>
+            /// <param name="DisableAllPrivilegs"></param>
+            /// <param name="NewState"></param>
+            /// <param name="BufferLength"></param>
+            /// <param name="PreviousState"></param>
+            /// <param name="ReturnLength"></param>
+            /// <returns></returns>
+            [DllImport(AdjustTokenPrivilegesApiDllName, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool AdjustTokenPrivileges(IntPtr TokenHandle, bool DisableAllPrivilegs,
+                ref TOKEN_PRIVILEGES NewState, int BufferLength, IntPtr PreviousState, IntPtr ReturnLength);
+
+            /// <summary>
+            /// PInvoke CloseHandle API
+            /// </summary>
+            /// <param name="hObject"></param>
+            /// <returns></returns>
+            [DllImport(CloseHandleApiDllName, ExactSpelling = true, SetLastError = true)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool CloseHandle(IntPtr hObject);
+
+            /// <summary>
+            /// Used to marshal win32 PRIVILEGE_SET structure to managed code layer
+            /// </summary>
+            [StructLayout(LayoutKind.Sequential, Pack = 1)]
+            public struct PRIVILEGE_SET
+            {
+                public int PrivilegeCount;
+                public int Control;
+                public long Luid;
+                public int Attributes;
+            }
+
+            /// <summary>
+            /// Used to marshal win32 TOKEN_PRIVILEGES structure to managed code layer
+            /// </summary>
+            [StructLayout(LayoutKind.Sequential, Pack = 1)]
+            public struct TOKEN_PRIVILEGES
+            {
+                public int PrivilegeCount;
+                public long Luid;
+                public int Attributes;
+            }
+
+            #endregion Win32 AdjustTokenPrivilege imports
+
+            #region Win32 SendMessage imports
+
+            /// <summary>
+            /// Definition of WM_SETTINGCHANGE constant from Win32 API
+            /// </summary>
+            public const int WM_SETTINGCHANGE = 0x001A;
+
+            /// <summary>
+            /// Definition of HWND_BROADCAST constant from Win32 API
+            /// </summary>
+            public const int HWND_BROADCAST = (-1);
+
+            /// <summary>
+            /// Definition of SMTO_ABORTIFHUNG constant from Win32 API
+            /// </summary>
+            public const int SMTO_ABORTIFHUNG = 0x0002;
+
+            /// <summary>
+            /// PInvoke SendMessageTimeout API
+            /// </summary>
+            /// <param name="hWnd"></param>
+            /// <param name="Msg"></param>
+            /// <param name="wParam"></param>
+            /// <param name="lParam"></param>
+            /// <param name="fuFlags"></param>
+            /// <param name="uTimeout"></param>
+            /// <param name="lpdwResult"></param>
+            /// <returns></returns>
+            [DllImport(SendMessageTimeoutApiDllName, SetLastError = true, CharSet = CharSet.Unicode)]
+            public static extern IntPtr SendMessageTimeout(IntPtr hWnd, int Msg, IntPtr wParam, string lParam, int fuFlags, int uTimeout, ref int lpdwResult);
+
+            #endregion Win32 SendMessage imports
+        }
+
+        #endregion Win32 interop helper
+    }
+
+
+    /// <summary>
+    /// static Helper class for working with system time zones.
+    /// </summary>
+    internal static class TimeZoneHelper
+    {
+        #region Error Ids
+
+        internal const string TimeZoneNotFoundError = "TimeZoneNotFound";
+        internal const string MultipleMatchingTimeZonesError = "MultipleMatchingTimeZones";
+        internal const string InsufficientPermissionsError = "InsufficientPermissions";
+        internal const string SetTimeZoneFailedError = "SetTimeZoneFailed";
+
+        #endregion Error Ids
+
+        /// <summary>
+        /// Clear the cached TimeZoneInfo data.  Note that since TimeZoneInfo.ClearCachedData
+        /// does not exist in .NET Core there is an alternative mechanism (which doesn't seem
+        /// to affect clearing out the cache under the full desktop version of .NET)
+        /// </summary>
+        internal static void ClearCachedData()
+        {
+#if CORECLR
+            // NOTE: .NET Core does not expose the ClearCachedData method, but executing
+            // the specific ConvertTime request below should have the same effect.
+            TimeZoneInfo.ConvertTime(new DateTime(0), TimeZoneInfo.Local);
+#else
+            TimeZoneInfo.ClearCachedData();
+#endif
+        }
+
+        /// <summary>
+        /// Find the system time zone by checking first against StandardName and then, 
+        /// if no matches were found, against the DaylightName.
+        /// </summary>
+        /// <param name="name">The name (or wildcard pattern) of the system time zone to find.</param>
+        /// <returns>A TimeZoneInfo object array containing information about the specified system time zones.</returns>
+        internal static TimeZoneInfo[] LookupSystemTimeZoneInfoByName(string name)
+        {
+            WildcardPattern namePattern = new WildcardPattern(name, WildcardOptions.IgnoreCase);
+            List<TimeZoneInfo> tzi = new List<TimeZoneInfo>();
+
+            // get the available system time zones
+            ReadOnlyCollection<TimeZoneInfo> zones = TimeZoneInfo.GetSystemTimeZones();
+
+            // check against the standard and daylight names for each TimeZoneInfo
+            foreach (TimeZoneInfo zone in zones)
+            {
+                if (namePattern.IsMatch(zone.StandardName) || namePattern.IsMatch(zone.DaylightName))
+                {
+                    tzi.Add(zone);
+                }
+            }
+
+            return (tzi.ToArray());
+        }
+    }
+}

src/Microsoft.PowerShell.Commands.Management/resources/TimeZoneResources.resx

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="MultipleMatchingTimeZones" xml:space="preserve">
+    <value>Cannot set the local time zone because the name '{0}' resolves to multiple entries.</value>
+  </data>
+  <data name="TimeZoneNameNotFound" xml:space="preserve">
+    <value>The time zone name '{0}' was not found on the local computer.</value>
+  </data>
+</root>