Rename options

UnitTests/Parse_policy_Tests.cs

@@ -73,7 +73,7 @@ public void add_Success()
         mock.Setup(m => m.PolicyAdd(It.IsAny<PolicyRule>(),
             It.IsNotNull<IConsole>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(ExitCode.Success));
 
-        Test(ExitCode.Success, mock, "policy", "add", "--type", "bind", "--access", "allow",
+        Test(ExitCode.Success, mock, "policy", "add", "--effect", "Allow", "--operation", "AutoBind",
             "--busid", TestBusId.ToString(), "--hardware-id", TestHardwareId.ToString());
     }
 

Usbipd/CommandHandlersCli.cs

@@ -138,7 +138,7 @@ Task<ExitCode> ICommandHandlers.List(bool usbids, IConsole console, Cancellation
             {
                 state = "Incompatible hub";
             }
-            else if (Policy.AllowBind(device))
+            else if (Policy.IsAutoBindAllowed(device))
             {
                 state = "Allowed";
             }
@@ -362,9 +362,9 @@ async Task<ExitCode> ICommandHandlers.AttachWsl(BusId busId, bool autoAttach, st
             console.ReportError($"There is no device with busid '{busId}'.");
             return ExitCode.Failure;
         }
-        if (!device.Guid.HasValue)
+        if (!device.Guid.HasValue && !Policy.IsAutoBindAllowed(device))
         {
-            console.ReportError($"Device is not shared; run 'usbipd bind -b {busId}' as administrator first.");
+            console.ReportError($"Device is not shared; run 'usbipd bind --busid {busId}' as administrator first.");
             return ExitCode.Failure;
         }
         // We allow auto-attach on devices that are already attached.
@@ -500,18 +500,18 @@ Task<ExitCode> ICommandHandlers.PolicyList(IConsole console, CancellationToken c
     {
         var policyRules = RegistryUtils.GetPolicyRules();
         console.WriteLine("Policy rules:");
-        console.WriteLine($"{"GUID",-36}  {"TYPE",-4}  {"ACCESS",-6}  {"BUSID",-5}  {"VID:PID",-9}");
+        console.WriteLine($"{"GUID",-36}  {"EFFECT",-6}  {"OPERATION",-9}  {"BUSID",-5}  {"VID:PID",-9}");
         foreach (var rule in policyRules)
         {
             console.Write($"{rule.Key,-36}  ");
-            console.Write($"{rule.Value.Type,-4}  ");
-            console.Write($"{(rule.Value.Allow ? "Allow" : "Deny"),-6}  ");
-            switch (rule.Value.Type)
+            console.Write($"{rule.Value.Effect,-6}  ");
+            console.Write($"{rule.Value.Operation,-9}  ");
+            switch (rule.Value.Operation)
             {
-                case PolicyRuleType.Bind:
-                    var ruleBind = (PolicyRuleBind)rule.Value;
-                    console.Write($"{(ruleBind.BusId.HasValue ? ruleBind.BusId.Value : string.Empty),-5}  ");
-                    console.Write($"{(ruleBind.HardwareId.HasValue ? ruleBind.HardwareId.Value : string.Empty),-9}");
+                case PolicyRuleOperation.AutoBind:
+                    var autoBind = (PolicyRuleAutoBind)rule.Value;
+                    console.Write($"{(autoBind.BusId.HasValue ? autoBind.BusId.Value : string.Empty),-5}  ");
+                    console.Write($"{(autoBind.HardwareId.HasValue ? autoBind.HardwareId.Value : string.Empty),-9}");
                     break;
             }
             console.WriteLine(string.Empty);
@@ -536,4 +536,15 @@ Task<ExitCode> ICommandHandlers.PolicyRemove(Guid guid, IConsole console, Cancel
         RegistryUtils.RemovePolicyRule(guid);
         return Task.FromResult(ExitCode.Success);
     }
+
+    Task<ExitCode> ICommandHandlers.PolicyRemoveAll(IConsole console, CancellationToken cancellationToken)
+    {
+        if (!CheckWriteAccess(console))
+        {
+            return Task.FromResult(ExitCode.AccessDenied);
+        }
+
+        RegistryUtils.RemovePolicyRuleAll();
+        return Task.FromResult(ExitCode.Success);
+    }
 }

Usbipd/ConnectedClient.cs

@@ -75,7 +75,7 @@ static IEnumerable<UsbDevice> GetDevicesAvailableForClient(IPAddress ipAddress)
                 // Device is already bound, so available for attach.
                 return true;
             }
-            return Policy.AllowBind(device, ipAddress);
+            return Policy.IsAutoBindAllowed(device, ipAddress);
         });
     }
 

Usbipd/ICommandHandlers.cs

@@ -29,4 +29,5 @@ interface ICommandHandlers
     public Task<ExitCode> PolicyAdd(PolicyRule rule, IConsole console, CancellationToken cancellationToken);
     public Task<ExitCode> PolicyList(IConsole console, CancellationToken cancellationToken);
     public Task<ExitCode> PolicyRemove(Guid guid, IConsole console, CancellationToken cancellationToken);
+    public Task<ExitCode> PolicyRemoveAll(IConsole console, CancellationToken cancellationToken);
 }

Usbipd/Policy.cs

@@ -10,14 +10,15 @@ static class Policy
 {
     // If client == null, then it is ignored. This should only be used for listing the devices locally
     // to determine if the device is allowed for at least one client.
-    public static bool AllowBind(UsbDevice device, IPAddress? client = null)
+    // NOTE: client == null is currently also used by 'attach -wsl', until we can reliably detect WSL connections.
+    public static bool IsAutoBindAllowed(UsbDevice device, IPAddress? client = null)
     {
         // Firewalling is not supported yet.
         _ = client;
 
         var rules = RegistryUtils.GetPolicyRules();
-        var allowed = rules.Values.Where(r => r.Allow);
-        var denied = rules.Values.Where(r => !r.Allow);
+        var allowed = rules.Values.Where(r => r.Effect == PolicyRuleEffect.Allow);
+        var denied = rules.Values.Where(r => r.Effect == PolicyRuleEffect.Deny);
 
         return allowed.Any(r => r.Matches(device)) && !denied.Any(r => r.Matches(device));
     }

Usbipd/PolicyRule.cs

@@ -6,7 +6,7 @@
 
 namespace Usbipd;
 
-abstract record PolicyRule(bool Allow, PolicyRuleType Type)
+abstract record PolicyRule(PolicyRuleEffect Effect, PolicyRuleOperation Operation)
 {
     public abstract bool IsValid();
 

Usbipd/PolicyRuleBind.cs → Usbipd/PolicyRuleAutoBind.cs

@@ -7,8 +7,8 @@
 
 namespace Usbipd;
 
-sealed record PolicyRuleBind(bool allow, BusId? BusId, VidPid? HardwareId)
-    : PolicyRule(allow, PolicyRuleType.Bind)
+sealed record PolicyRuleAutoBind(PolicyRuleEffect effect, BusId? BusId, VidPid? HardwareId)
+    : PolicyRule(effect, PolicyRuleOperation.AutoBind)
 {
     const string BusIdName = "BusId";
     const string HardwareIdName = "HardwareId";
@@ -46,7 +46,7 @@ public override void Save(RegistryKey registryKey)
         }
     }
 
-    public static PolicyRuleBind Load(bool allow, RegistryKey registryKey)
+    public static PolicyRuleAutoBind Load(PolicyRuleEffect access, RegistryKey registryKey)
     {
         BusId? busId = null;
         if (Automation.BusId.TryParse(registryKey.GetValue(BusIdName) as string ?? string.Empty, out var parsedBusId))
@@ -58,6 +58,6 @@ public static PolicyRuleBind Load(bool allow, RegistryKey registryKey)
         {
             hardwareId = parsedHardwareId;
         }
-        return new(allow, busId, hardwareId);
+        return new(access, busId, hardwareId);
     }
 }

Usbipd/PolicyRuleAccess.cs → Usbipd/PolicyRuleEffect.cs

@@ -4,7 +4,7 @@
 
 namespace Usbipd;
 
-public enum PolicyRuleAccess
+public enum PolicyRuleEffect
 {
     Allow,
     Deny,

Usbipd/PolicyRuleType.cs → Usbipd/PolicyRuleOperation.cs

@@ -4,7 +4,7 @@
 
 namespace Usbipd;
 
-public enum PolicyRuleType
+public enum PolicyRuleOperation
 {
-    Bind,
+    AutoBind,
 }

Usbipd/Program.cs

@@ -416,28 +416,28 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
             //  policy
             //
             var policyCommand = new Command("policy", "Manage policy rules\0"
-                + "Policy rules allow or deny specific functionality, such as bind and attach.\n");
+                + "Policy rules allow or deny specific operations.");
             {
                 //
-                //  policy add --access <ACCESS>
+                //  policy add --effect <EFFECT>
                 //
-                var accessOption = new Option<PolicyRuleAccess>(
-                    aliases: ["--access", "-a"]
+                var effectOption = new Option<PolicyRuleEffect>(
+                    aliases: ["--effect", "-e"]
                 )
                 {
-                    ArgumentHelpName = "ACCESS",
+                    ArgumentHelpName = "EFFECT",
                     Description = "Allow or Deny",
                     IsRequired = true,
                 };
                 //
-                //  policy add --type <TYPE>
+                //  policy add --operation <OPERATION>
                 //
-                var typeOption = new Option<PolicyRuleType>(
-                    aliases: ["--type", "-t"]
+                var operationOption = new Option<PolicyRuleOperation>(
+                    aliases: ["--operation", "-o"]
                 )
                 {
-                    ArgumentHelpName = "TYPE",
-                    Description = "Add a policy rule of type <TYPE>",
+                    ArgumentHelpName = "OPERATION",
+                    Description = "Currently only supports 'AutoBind'",
                     IsRequired = true,
                 };
                 //
@@ -472,8 +472,8 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
                     + "\n"
                     + AtLeastOneOfRequiredText(busIdOption, hardwareIdOption))
                 {
-                    accessOption,
-                    typeOption,
+                    effectOption,
+                    operationOption,
                     busIdOption,
                     hardwareIdOption,
                 };
@@ -483,15 +483,15 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
                 });
                 addCommand.SetHandler(async invocationContext =>
                 {
-                    var policyRuleType = invocationContext.ParseResult.GetValueForOption(typeOption);
-                    invocationContext.ExitCode = (int)await (policyRuleType switch
+                    var operation = invocationContext.ParseResult.GetValueForOption(operationOption);
+                    invocationContext.ExitCode = (int)await (operation switch
                     {
-                        PolicyRuleType.Bind =>
-                            commandHandlers.PolicyAdd(new PolicyRuleBind(invocationContext.ParseResult.GetValueForOption(accessOption) == PolicyRuleAccess.Allow,
+                        PolicyRuleOperation.AutoBind =>
+                            commandHandlers.PolicyAdd(new PolicyRuleAutoBind(invocationContext.ParseResult.GetValueForOption(effectOption),
                                     invocationContext.ParseResult.GetValueForOptionOrNull(busIdOption),
                                     invocationContext.ParseResult.GetValueForOptionOrNull(hardwareIdOption)),
                                 invocationContext.Console, invocationContext.GetCancellationToken()),
-                        _ => throw new UnexpectedResultException($"Unexpected policy rule type '{policyRuleType}'."),
+                        _ => throw new UnexpectedResultException($"Unexpected policy rule operation '{operation}'."),
                     });
                 });
                 policyCommand.AddCommand(addCommand);
@@ -501,7 +501,7 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
                 //  policy list
                 //
                 var listCommand = new Command("list", "List policy rules\0"
-                    + "List all policy rules.\n");
+                    + "List all policy rules.");
                 listCommand.SetHandler(async invocationContext =>
                 {
                     invocationContext.ExitCode = (int)
@@ -511,7 +511,17 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
             }
             {
                 //
-                //  policy remove --guid <GUID>
+                //  policy remove [--all]
+                //
+                var allOption = new Option<bool>(
+                    aliases: ["--all", "-a"]
+                )
+                {
+                    Description = "Remove all policy rules",
+                    Arity = ArgumentArity.Zero,
+                };
+                //
+                //  policy remove [--guid <GUID>]
                 //
                 var guidOption = new Option<Guid>(
                     aliases: ["--guid", "-g"],
@@ -520,22 +530,36 @@ await commandHandlers.List(invocationContext.ParseResult.HasOption(usbidsOption)
                 {
                     ArgumentHelpName = "GUID",
                     Description = "Remove the policy rule having <GUID>",
-                    IsRequired = true,
                 }.AddCompletions(completionContext => CompletionGuard(completionContext, () =>
                     RegistryUtils.GetPolicyRules().Select(r => r.Key.ToString("D"))));
                 //
                 //  policy remove
                 //
                 var removeCommand = new Command("remove", "Remove a policy rule\0"
-                    + "Remove an existing policy rule. The resulting policy will be effective immediately.\n")
+                    + "Remove existing policy rules. The resulting policy will be effective immediately.\n"
+                    + "\n"
+                    + OneOfRequiredText(allOption, guidOption))
                 {
+                    allOption,
                     guidOption,
                 };
+                removeCommand.AddValidator(commandResult =>
+                {
+                    ValidateOneOf(commandResult, allOption, guidOption);
+                });
                 removeCommand.SetHandler(async invocationContext =>
                 {
-                    invocationContext.ExitCode = (int)
-                        await commandHandlers.PolicyRemove(invocationContext.ParseResult.GetValueForOption(guidOption),
-                            invocationContext.Console, invocationContext.GetCancellationToken());
+                    if (invocationContext.ParseResult.HasOption(allOption))
+                    {
+                        invocationContext.ExitCode = (int)
+                            await commandHandlers.PolicyRemoveAll(invocationContext.Console, invocationContext.GetCancellationToken());
+                    }
+                    else
+                    {
+                        invocationContext.ExitCode = (int)
+                            await commandHandlers.PolicyRemove(invocationContext.ParseResult.GetValueForOption(guidOption),
+                                invocationContext.Console, invocationContext.GetCancellationToken());
+                    }
                 });
                 policyCommand.AddCommand(removeCommand);
             }

Usbipd/RegistryUtils.cs

@@ -35,8 +35,8 @@ static RegistryKey OpenBaseKey(bool writable)
     const string BusIdName = "BusId";
     const string IPAddressName = "IPAddress";
     const string PolicyName = "Policy";
-    const string TypeName = "Type";
-    const string AllowName = "Allow";
+    const string EffectName = "Effect";
+    const string OperationName = "Operation";
 
     /// <summary>
     /// <see langword="null"/> if not installed
@@ -252,8 +252,8 @@ public static Guid AddPolicyRule(PolicyRule rule)
         }
         var guid = Guid.NewGuid();
         using var ruleKey = GetPolicyKey(true).CreateSubKey($"{guid:B}");
-        ruleKey.SetValue(AllowName, rule.Allow ? 1 : 0);
-        ruleKey.SetValue(TypeName, rule.Type.ToString());
+        ruleKey.SetValue(EffectName, rule.Effect.ToString());
+        ruleKey.SetValue(OperationName, rule.Operation.ToString());
         rule.Save(ruleKey);
         return guid;
     }
@@ -264,6 +264,15 @@ public static void RemovePolicyRule(Guid guid)
         policyKey.DeleteSubKeyTree(guid.ToString("B"), false);
     }
 
+    public static void RemovePolicyRuleAll()
+    {
+        using var policyKey = GetPolicyKey(true);
+        foreach (var subKeyName in policyKey.GetSubKeyNames())
+        {
+            policyKey.DeleteSubKeyTree(subKeyName, false);
+        }
+    }
+
     /// <summary>
     /// Enumerates all rules.
     /// <para>
@@ -291,22 +300,21 @@ public static SortedDictionary<Guid, PolicyRule> GetPolicyRules()
             {
                 continue;
             }
-            if (ruleKey.GetValue(AllowName) is not int allowValue)
+            if (!Enum.TryParse<PolicyRuleEffect>(ruleKey.GetValue(EffectName) as string, true, out var effect))
             {
-                // Must exist and be a DWORD.
+                // Must exist and be a valid enum string.
                 continue;
             }
-            var allow = (allowValue != 0);
-            if (!Enum.TryParse<PolicyRuleType>(ruleKey.GetValue(TypeName) as string, true, out var ruleType))
+            if (!Enum.TryParse<PolicyRuleOperation>(ruleKey.GetValue(OperationName) as string, true, out var operation))
             {
                 // Must exist and be a valid enum string.
                 continue;
             }
             PolicyRule rule;
-            switch (ruleType)
+            switch (operation)
             {
-                case PolicyRuleType.Bind:
-                    rule = PolicyRuleBind.Load(allow, ruleKey);
+                case PolicyRuleOperation.AutoBind:
+                    rule = PolicyRuleAutoBind.Load(effect, ruleKey);
                     break;
                 default:
                     // Invalid, ignore.