예제 #1
0
            /// <summary>
            /// Moves to the next task. See MoveNext for more information.
            /// </summary>
            /// <returns>true if next task found, false if no more tasks.</returns>
            public bool MoveNext()
            {
                IntPtr names = IntPtr.Zero;
                bool   valid = false;

                do
                {
                    curItem = null;
                    uint uFetched = 0;
                    try
                    {
                        wienum.Next(1, out names, out uFetched);
                        if (uFetched != 1)
                        {
                            break;
                        }
                        using (V1Interop.CoTaskMemString name = new V1Interop.CoTaskMemString(Marshal.ReadIntPtr(names)))
                            curItem = name.ToString();
                        if (curItem.EndsWith(".job", StringComparison.InvariantCultureIgnoreCase))
                        {
                            curItem = curItem.Remove(curItem.Length - 4);
                        }
                    }
                    catch { }
                    finally { Marshal.FreeCoTaskMem(names); names = IntPtr.Zero; }

                    // If name doesn't match filter, look for next item
                    if (filter != null)
                    {
                        if (!filter.IsMatch(curItem))
                        {
                            continue;
                        }
                    }

                    V1Interop.ITask itask = null;
                    try { itask = this.ICurrent; valid = true; }
                    catch { valid = false; }
                    finally { itask = null; }
                } while (!valid);

                return(curItem != null);
            }
예제 #2
0
        /// <summary>
        /// Registers (creates) a task in a specified location using a <see cref="TaskDefinition"/> instance to define a task.
        /// </summary>
        /// <param name="Path">The task name. If this value is NULL, the task will be registered in the root task folder and the task name will be a GUID value that is created by the Task Scheduler service. A task name cannot begin or end with a space character. The '.' character cannot be used to specify the current task folder and the '..' characters cannot be used to specify the parent task folder in the path.</param>
        /// <param name="definition">The <see cref="TaskDefinition"/> of the registered task.</param>
        /// <param name="createType">A union of <see cref="TaskCreation"/> flags.</param>
        /// <param name="UserId">The user credentials used to register the task.</param>
        /// <param name="password">The password for the userId used to register the task.</param>
        /// <param name="LogonType">A <see cref="TaskLogonType"/> value that defines what logon technique is used to run the registered task.</param>
        /// <param name="sddl">The security descriptor associated with the registered task. You can specify the access control list (ACL) in the security descriptor for a task in order to allow or deny certain users and groups access to a task.</param>
        /// <returns>A <see cref="Task"/> instance that represents the new task.</returns>
        public Task RegisterTaskDefinition(string Path, TaskDefinition definition, TaskCreation createType, string UserId, string password = null, TaskLogonType LogonType = TaskLogonType.S4U, string sddl = null)
        {
            if (v2Folder != null)
            {
                return(new Task(this.TaskService, v2Folder.RegisterTaskDefinition(Path, definition.v2Def, (int)createType, UserId, password, LogonType, sddl)));
            }

            // Adds ability to set a password for a V1 task. Provided by Arcao.
            V1Interop.TaskFlags flags = definition.v1Task.GetFlags();
            if (LogonType == TaskLogonType.InteractiveTokenOrPassword && string.IsNullOrEmpty(password))
            {
                LogonType = TaskLogonType.InteractiveToken;
            }
            switch (LogonType)
            {
            case TaskLogonType.Group:
            case TaskLogonType.S4U:
            case TaskLogonType.None:
                throw new NotV1SupportedException("This LogonType is not supported on Task Scheduler 1.0.");

            case TaskLogonType.InteractiveToken:
                flags |= (V1Interop.TaskFlags.RunOnlyIfLoggedOn | V1Interop.TaskFlags.Interactive);
                if (String.IsNullOrEmpty(UserId))
                {
                    UserId = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
                }
                definition.v1Task.SetAccountInformation(UserId, IntPtr.Zero);
                break;

            case TaskLogonType.ServiceAccount:
                flags &= ~(V1Interop.TaskFlags.Interactive | V1Interop.TaskFlags.RunOnlyIfLoggedOn);
                definition.v1Task.SetAccountInformation((String.IsNullOrEmpty(UserId) || UserId.Equals("SYSTEM", StringComparison.CurrentCultureIgnoreCase)) ? String.Empty : UserId, IntPtr.Zero);
                break;

            case TaskLogonType.InteractiveTokenOrPassword:
                flags |= V1Interop.TaskFlags.Interactive;
                using (V1Interop.CoTaskMemString cpwd = new V1Interop.CoTaskMemString(password))
                    definition.v1Task.SetAccountInformation(UserId, cpwd.DangerousGetHandle());
                break;

            case TaskLogonType.Password:
                using (V1Interop.CoTaskMemString cpwd = new V1Interop.CoTaskMemString(password))
                    definition.v1Task.SetAccountInformation(UserId, cpwd.DangerousGetHandle());
                break;

            default:
                break;
            }
            definition.v1Task.SetFlags(flags);

            switch (createType)
            {
            case TaskCreation.Create:
            case TaskCreation.CreateOrUpdate:
            case TaskCreation.Disable:
            case TaskCreation.Update:
                if (createType == TaskCreation.Disable)
                {
                    definition.Settings.Enabled = false;
                }
                definition.V1Save(Path);
                break;

            case TaskCreation.DontAddPrincipalAce:
                throw new NotV1SupportedException("Security settings are not available on Task Scheduler 1.0.");

            case TaskCreation.IgnoreRegistrationTriggers:
                throw new NotV1SupportedException("Registration triggers are not available on Task Scheduler 1.0.");

            case TaskCreation.ValidateOnly:
                throw new NotV1SupportedException("Xml validation not available on Task Scheduler 1.0.");

            default:
                break;
            }
            return(new Task(this.TaskService, definition.v1Task));
        }