vagrant-qemu 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0968c034faf465b2d51e1f7b785a7a1aed39a4d6c40ef96f6b34147e9ab8ebd
-  data.tar.gz: fff8fc272c6c99abb85ccff761137f53ee6aabe8953f4b702ffca61163ea8d27
+  metadata.gz: 00ee57a8b6cb0315b36c0084239e92ed69633698845945e6290ba289d71e2889
+  data.tar.gz: 99985f04eabced2eabae1914eacb19f053f13613a4f18d40047ac57440bd4a52
 SHA512:
-  metadata.gz: ba77c0b50cd06921799dcc154f8d987a3fe1e367fd4347bbd2a45381f0819815e9f832f29be04a76818fb5e5c24abb4f009fb33350aace09486f1a20f6250012
-  data.tar.gz: 6438ed9c811e25f7393e59971028eea43b5f3d76ac9a11982dd2424c8b7cbd54181cbaa514875aebbb54f38520fcab12575929e5c62259f42c37cce83274c34a
+  metadata.gz: ffc285799ee3f7be527da85b03d539c6f1f6b9278bc474c00b63eef41ea937bd8d5bf17aae125d801d3e1a9404967b1df9f0fa2b3173f3db452ed0fc60a12727
+  data.tar.gz: 43601507f85d2bb8e884e24795cdbb64c4d2d03f3842c1a8feb5cefe437241cdc0bcbbc531da4036540b3e19f6aaf831f9b35cad6c91c29c32da42be5f90abb0

data/CHANGELOG.md

@@ -154,3 +154,18 @@
   core packaging middleware. Environment-specific state — networking, MAC,
   additional disks, DVDs/cloud-init seed ISOs, and firmware — is intentionally
   not baked into the box.
+
+# 0.6.0 (2026-07-21)
+
+* `net_mode = :socket_vmnet` adds no-sudo private networking on macOS: the
+  [socket_vmnet](https://github.com/lima-vm/socket_vmnet) daemon holds the root
+  vmnet membership and QEMU connects to it as a normal user, so `vagrant up`
+  and the other lifecycle commands need no sudo. It reuses the advanced-network
+  dual-NIC + cloud-init path — NIC 0 user-mode (SSH + port forwarding), NIC 1
+  on socket_vmnet with the configured static IP — giving host↔VM and VM↔VM
+  connectivity. On QEMU >= 7.2 QEMU connects to the daemon directly
+  (`-netdev stream`); on older QEMU it falls back to the `socket_vmnet_client`
+  wrapper (`-netdev socket,fd=3`), chosen automatically by probing the QEMU
+  binary. New config: `socket_vmnet_socket` and `socket_vmnet_client` (default
+  to the Homebrew prefix). The static IP must fall within the daemon's subnet
+  (`--vmnet-gateway`, default `192.168.105.1/24`); see the README. (#41)

data/README.md

@@ -108,11 +108,13 @@ This provider exposes a few provider-specific configuration options:
   * `graceful_timeout` - Seconds to wait at each `vagrant halt` stage before escalating, default: `60`. Halt sends ACPI `system_powerdown`, waits up to this long, then sends QEMU's `quit` monitor command (a clean shutdown that flushes and closes the disk images), waits again, and finally SIGKILLs QEMU as a last resort — so halt still completes even when the guest was already halted from inside (e.g. `sudo systemctl halt`), where `system_powerdown` is a no-op
 * advanced networking (requires `advanced_network = true`)
   * `advanced_network` - Enable dual-NIC advanced networking with `private_network` support, default: `false`
-  * `net_mode` - Network backend: `:auto` (detect by platform), `:vmnet_shared`, `:vmnet_host`, `:vmnet_bridged` (macOS), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`
+  * `net_mode` - Network backend: `:auto` (detect by platform), `:vmnet_shared`, `:vmnet_host`, `:vmnet_bridged` (macOS, sudo), `:socket_vmnet` (macOS, no sudo — via the socket_vmnet daemon), `:tap` (Linux), `:socket` (QEMU `socket` netdev — multicast or point-to-point, see `socket_opts`), default: `:auto`
   * `vmnet_interface` - Physical interface for vmnet-bridged mode, default: `en0`
   * `tap_device` - TAP device name for Linux tap backend, default: `nil` (uses `tap0`)
   * `mcast_addr` - Convenience shortcut for the `:socket` backend's multicast address, default: `nil` (uses `230.0.0.1:1234`)
   * `socket_opts` - Raw options for the `:socket` netdev, emitted verbatim as `-netdev socket,id=netN,<socket_opts>`. You pick the mode: `"mcast=230.0.0.1:1234"` (multicast, N-way), `"listen=:1234"` / `"connect=127.0.0.1:1234"` (point-to-point; you decide which VM listens and which connects — the no-root, macOS-friendly path). Overrides `mcast_addr`. Default: `nil` (falls back to multicast)
+  * `socket_vmnet_socket` - Path to the socket_vmnet daemon's unix socket, used by the `:socket_vmnet` backend, default: `<homebrew-prefix>/var/run/socket_vmnet` (`HOMEBREW_PREFIX` env, else `/opt/homebrew` on Apple Silicon, `/usr/local` on Intel)
+  * `socket_vmnet_client` - Path to the `socket_vmnet_client` wrapper, used only on QEMU older than 7.2 (which lacks the native `stream` netdev), default: `<homebrew-prefix>/opt/socket_vmnet/bin/socket_vmnet_client`
 
 ### Usage
 
@@ -320,7 +322,7 @@ See the [QEMU Documentation](https://www.qemu.org/docs/master/devel/multiple-iot
 
 12. Advanced networking with private_network
 
-Pick a backend with `net_mode`: QEMU's native vmnet.framework on macOS (requires sudo), TAP on Linux, or the `socket` netdev. The `:socket` backend is a thin wrapper around QEMU's `socket` netdev — you choose the mode in `socket_opts`: `mcast=` (multicast, N-way, Linux/Windows) or `listen=`/`connect=` (point-to-point, no root, works on macOS). The plugin creates two NICs: NIC 0 (user-mode for SSH and port forwarding) and NIC 1 (platform backend for VM networking). The static IP is delivered via a cloud-init NoCloud seed ISO that the plugin builds and attaches automatically; the NICs are matched by MAC address, never by interface order.
+Pick a backend with `net_mode`: QEMU's native vmnet.framework on macOS (`:vmnet_shared`/`_host`/`_bridged`, requires sudo), `:socket_vmnet` on macOS (full host↔VM and VM↔VM **without** sudo, via the [socket_vmnet](https://github.com/lima-vm/socket_vmnet) daemon), TAP on Linux, or the `socket` netdev. The `:socket` backend is a thin wrapper around QEMU's `socket` netdev — you choose the mode in `socket_opts`: `mcast=` (multicast, N-way, Linux/Windows) or `listen=`/`connect=` (point-to-point, no root, works on macOS). The plugin creates two NICs: NIC 0 (user-mode for SSH and port forwarding) and NIC 1 (platform backend for VM networking). The static IP is delivered via a cloud-init NoCloud seed ISO that the plugin builds and attaches automatically; the NICs are matched by MAC address, never by interface order.
 
 For VM-to-VM networking on macOS without sudo, use `:socket` with a `listen`/`connect` pair — you decide which VM listens and which connects:
 
@@ -366,6 +368,38 @@ Vagrant.configure("2") do |config|
 end
 ```
 
+Full networking on macOS **without sudo** with `:socket_vmnet` (host↔VM and VM↔VM, static IP):
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "perk/ubuntu-2204-arm64"  # an aarch64 cloud-init box
+  config.vm.network "private_network", ip: "192.168.105.10"
+
+  config.vm.provider "qemu" do |qe|
+    qe.advanced_network = true
+    qe.net_mode = :socket_vmnet
+    # qe.socket_vmnet_socket = "/opt/homebrew/var/run/socket_vmnet"  # default (Homebrew prefix)
+  end
+end
+```
+
+Set up the daemon once (root, one-time), then run `vagrant up` as your normal user:
+
+```sh
+brew install socket_vmnet
+# Reserve a static-IP range so cloud-init IPs don't collide with the DHCP pool:
+sudo brew services start socket_vmnet   # or run it with explicit flags, e.g.:
+# sudo socket_vmnet --vmnet-gateway=192.168.105.1 --vmnet-dhcp-end=192.168.105.100 \
+#     /opt/homebrew/var/run/socket_vmnet
+```
+
+The `private_network` IP must sit inside the daemon's subnet (`--vmnet-gateway`, default
+`192.168.105.1/24`) and, to avoid a DHCP clash, above `--vmnet-dhcp-end`. Unlike the native vmnet
+backends, `:socket_vmnet` cannot tell the daemon which subnet to use — the daemon's launch flags are
+authoritative, so align the IP to them. On QEMU ≥ 7.2 the plugin connects to the daemon directly
+(`-netdev stream`); on older QEMU it automatically falls back to the `socket_vmnet_client` wrapper
+(configurable via `qe.socket_vmnet_client`).
+
 Notes:
 * The guest image must include cloud-init, otherwise the static IP is silently not applied
 * On macOS, vmnet requires root: run `sudo vagrant up` (and the other lifecycle commands such as `halt`/`reload`/`destroy`), because the plugin launches QEMU as a child of the Vagrant process and does not elevate it on its own. The plugin warns when vmnet is selected and Vagrant is not running as root.
@@ -374,7 +408,7 @@ Notes:
   sudo chown -R "$(id -un)":staff ~/.vagrant.d/boxes/<box> .vagrant
   ```
   Pre-adding boxes as your normal user (`vagrant box add <box>`) before the first `sudo vagrant up` also avoids the box ending up root-owned.
-* To avoid root (and this side effect) entirely on macOS, use [`socket_vmnet`](https://github.com/lima-vm/socket_vmnet) — a small root helper daemon you install once, which QEMU then connects to as a normal user (the approach Lima/Colima/minikube take). The `com.apple.developer.networking.vmnet` entitlement could also bypass root in principle, but it is a *restricted* Apple entitlement that requires an Apple-provisioned signing certificate and cannot be ad-hoc / self-signed onto Homebrew's QEMU, so it is not a practical option for individual users.
+* To avoid root (and this side effect) entirely on macOS, use `net_mode = :socket_vmnet` (see the example above): the [`socket_vmnet`](https://github.com/lima-vm/socket_vmnet) daemon holds the root vmnet membership and QEMU connects to it as a normal user (the approach Lima/Colima/minikube take), so `vagrant up` and the other lifecycle commands need no sudo. The `com.apple.developer.networking.vmnet` entitlement could also bypass root in principle, but it is a *restricted* Apple entitlement that requires an Apple-provisioned signing certificate and cannot be ad-hoc / self-signed onto Homebrew's QEMU, so it is not a practical option for individual users.
 * Without `advanced_network = true`, the `private_network` configuration is ignored with a warning
 * When only one NIC is needed (no `private_network`), no cloud-init seed is attached, avoiding compatibility issues
 * Combining `advanced_network` with `config.vm.cloud_init` is supported: the plugin merges your user-data and the generated network-config into a single NoCloud seed
@@ -387,7 +421,8 @@ Platform support:
 
 | Platform | Backend (`net_mode`) | Host ↔ VM | VM ↔ VM | Root? | External dependency |
 |----------|---------|:---------:|:-------:|:-----:|:-------------------:|
-| macOS    | `:vmnet_shared`/`_host`/`_bridged` | Yes | Yes | sudo (or socket_vmnet) | None (QEMU >= 7.0) |
+| macOS    | `:vmnet_shared`/`_host`/`_bridged` | Yes | Yes | sudo | None (QEMU >= 7.0) |
+| macOS    | `:socket_vmnet` | Yes | Yes | No | socket_vmnet daemon (`brew install socket_vmnet`) |
 | macOS    | `:socket` (`listen`/`connect`) | No (use port forwarding) | Yes (2 VMs) | No | None |
 | Linux    | `:tap` + bridge | Yes | Yes | sudo | Pre-created tap device + bridge (`ip` command) |
 | Linux    | `:socket` (`mcast`) | No (use port forwarding) | Yes | No | None |

data/lib/vagrant-qemu/action/start_instance.rb

@@ -42,6 +42,8 @@ module VagrantPlugins
             :tap_device => config.tap_device,
             :mcast_addr => config.mcast_addr,
             :socket_opts => config.socket_opts,
+            :socket_vmnet_socket => config.socket_vmnet_socket,
+            :socket_vmnet_client => config.socket_vmnet_client,
           }
 
           # Pick up SSH port that may have been corrected by HandleForwardedPortCollisions

data/lib/vagrant-qemu/config.rb

@@ -29,7 +29,7 @@ module VagrantPlugins
       attr_accessor :graceful_timeout  # seconds to wait for guest shutdown before force kill
       # Advanced networking options
       attr_accessor :advanced_network   # bool, opt-in for dual-NIC setup
-      attr_accessor :net_mode           # :auto, :vmnet_shared, :vmnet_host, :vmnet_bridged, :tap, :socket
+      attr_accessor :net_mode           # :auto, :vmnet_shared, :vmnet_host, :vmnet_bridged, :tap, :socket, :socket_vmnet
       attr_accessor :vmnet_interface    # physical interface for vmnet-bridged (e.g. "en0")
       attr_accessor :tap_device         # tap device name for Linux tap backend
       attr_accessor :mcast_addr         # convenience shortcut for the :socket backend's multicast address
@@ -39,6 +39,10 @@ module VagrantPlugins
       # The mode (multicast vs point-to-point listen/connect) and any roles are
       # entirely the user's choice. Overrides mcast_addr when set.
       attr_accessor :socket_opts
+      # socket_vmnet backend (macOS): the daemon's unix socket, and the client
+      # wrapper used only on QEMU without the native `stream` netdev.
+      attr_accessor :socket_vmnet_socket
+      attr_accessor :socket_vmnet_client
 
       def initialize
         @ssh_host = UNSET_VALUE
@@ -71,6 +75,8 @@ module VagrantPlugins
         @tap_device = UNSET_VALUE
         @mcast_addr = UNSET_VALUE
         @socket_opts = UNSET_VALUE
+        @socket_vmnet_socket = UNSET_VALUE
+        @socket_vmnet_client = UNSET_VALUE
       end
 
       #-------------------------------------------------------------------
@@ -123,6 +129,8 @@ module VagrantPlugins
         @tap_device = nil if @tap_device == UNSET_VALUE
         @mcast_addr = nil if @mcast_addr == UNSET_VALUE
         @socket_opts = nil if @socket_opts == UNSET_VALUE
+        @socket_vmnet_socket = "#{homebrew_prefix}/var/run/socket_vmnet" if @socket_vmnet_socket == UNSET_VALUE
+        @socket_vmnet_client = "#{homebrew_prefix}/opt/socket_vmnet/bin/socket_vmnet_client" if @socket_vmnet_client == UNSET_VALUE
 
         # TODO better error msg
         @ssh_port = Integer(@ssh_port)
@@ -152,6 +160,14 @@ module VagrantPlugins
         end
       end
 
+      # Homebrew install prefix: env override, else the per-arch default
+      # (Apple Silicon vs Intel). Defaults to the host arch (socket_vmnet paths
+      # are host-side); default_qemu_dir passes the guest arch to keep its
+      # firmware-dir behavior.
+      def homebrew_prefix(arch = host_arch)
+        ENV["HOMEBREW_PREFIX"] || (arch == "aarch64" ? "/opt/homebrew" : "/usr/local")
+      end
+
       # QEMU data dir (firmware images). Only actually consumed for aarch64
       # firmware, but resolved generically: explicit env override, then the
       # Homebrew prefix, then a per-platform default.
@@ -161,7 +177,7 @@ module VagrantPlugins
 
         case RbConfig::CONFIG["host_os"]
         when /darwin/
-          arch == "aarch64" ? "/opt/homebrew/share/qemu" : "/usr/local/share/qemu"
+          "#{homebrew_prefix(arch)}/share/qemu"
         else
           "/usr/share/qemu"
         end

data/lib/vagrant-qemu/driver.rb

@@ -114,6 +114,7 @@ module VagrantPlugins
           cmd += %W(-m #{options[:memory]}) if !options[:memory].nil?
 
           # network
+          launch_prefix = []
           if !options[:net_device].nil?
             private_networks = options[:private_networks] || []
             use_advanced = options[:advanced_network] && !private_networks.empty?
@@ -139,8 +140,12 @@ module VagrantPlugins
               # (the static-IP cloud-init seed is built and attached by the
               # CloudInitNetwork action, not here)
               backend = Network.backend_for(options[:net_mode])
+              backend.preflight!(options, qemu_binary)
               cmd += %W(-device #{options[:net_device]},netdev=net1,mac=#{mac1})
               cmd += backend.build_netdev_args("net1", options)
+              # launch_prefix is applied under the same gate as build_netdev_args
+              # (empty for every backend except socket_vmnet's wrapper route).
+              launch_prefix = backend.launch_prefix(options)
             else
               # Single NIC: user-mode only (original behavior, no cloud-init)
               cmd += %W(-device #{options[:net_device]},netdev=net0)
@@ -206,6 +211,10 @@ module VagrantPlugins
           # user-defined
           cmd += options[:extra_qemu_args]
 
+          # socket_vmnet wrapper route: launch qemu under socket_vmnet_client
+          # (empty prefix otherwise -> zero difference from the current path).
+          cmd = launch_prefix + cmd
+
           opts = {:detach => options[:no_daemonize]}
           execute(*cmd, **opts)
         end

data/lib/vagrant-qemu/errors.rb

@@ -38,6 +38,18 @@ module VagrantPlugins
       class DestroyError < VagrantQEMUError
         error_key(:destroy_error)
       end
+
+      class SocketVmnetNotMacos < VagrantQEMUError
+        error_key(:socket_vmnet_not_macos)
+      end
+
+      class SocketVmnetSocketNotFound < VagrantQEMUError
+        error_key(:socket_vmnet_socket_not_found)
+      end
+
+      class SocketVmnetClientNotFound < VagrantQEMUError
+        error_key(:socket_vmnet_client_not_found)
+      end
     end
   end
 end

data/lib/vagrant-qemu/network/base.rb

@@ -15,6 +15,23 @@ module VagrantPlugins
         def requires_sudo?
           false
         end
+
+        # Tokens to prepend to the QEMU launch command (a wrapper program).
+        # Empty by default; only socket_vmnet's wrapper route is non-empty.
+        # The driver applies this under the same gate as build_netdev_args.
+        # @param options [Hash] provider config options
+        # @return [Array<String>]
+        def launch_prefix(options)
+          []
+        end
+
+        # Validate preconditions and resolve any backend-specific options
+        # before the command is built. No-op by default; the driver calls it
+        # under the same gate as build_netdev_args.
+        # @param options [Hash] provider config options (may be mutated)
+        # @param qemu_binary [String] the resolved qemu-system-* binary
+        def preflight!(options, qemu_binary)
+        end
       end
     end
   end

data/lib/vagrant-qemu/network/socket_vmnet.rb

@@ -0,0 +1,60 @@
+require_relative "base"
+require_relative "../errors"
+
+module VagrantPlugins
+  module QEMU
+    module Network
+      # socket_vmnet backend (macOS) -- connects the private NIC to a
+      # socket_vmnet daemon so QEMU runs without sudo (the daemon holds the
+      # root vmnet.framework membership).
+      #
+      # Two routes, chosen by whether the QEMU binary has the native `stream`
+      # netdev (options[:use_stream], set by the driver from a probe):
+      #   stream (QEMU >= 7.2): QEMU connects to the daemon's unix socket
+      #     directly -- a pure netdev backend, no launch wrapper.
+      #   wrapper (older QEMU): QEMU is launched under `socket_vmnet_client
+      #     <sock>`, which hands the connection in on fd 3.
+      #
+      # build_netdev_args and launch_prefix are driven by the same use_stream
+      # so they never disagree.
+      class SocketVmnet < Base
+        # Resolve the route and fail fast on missing preconditions. Sets
+        # options[:use_stream]: true when the qemu binary has the native
+        # `stream` netdev, false when it definitively lacks it, and true when
+        # the probe couldn't determine (rare) -- stream needs no extra dependency.
+        def preflight!(options, qemu_binary)
+          raise Errors::SocketVmnetNotMacos unless RbConfig::CONFIG["host_os"] =~ /darwin/
+
+          options[:use_stream] = Network.qemu_supports_stream?(qemu_binary) != false
+
+          socket = options[:socket_vmnet_socket]
+          unless socket && File.exist?(socket)
+            raise Errors::SocketVmnetSocketNotFound, socket: socket
+          end
+
+          return if options[:use_stream]
+
+          client = options[:socket_vmnet_client]
+          unless client && (::Vagrant::Util::Which.which(client) || File.executable?(client))
+            raise Errors::SocketVmnetClientNotFound, client: client
+          end
+        end
+
+        def build_netdev_args(id, options)
+          if options[:use_stream]
+            sock = options[:socket_vmnet_socket]
+            %W(-netdev stream,id=#{id},server=off,addr.type=unix,addr.path=#{sock})
+          else
+            %W(-netdev socket,id=#{id},fd=3)
+          end
+        end
+
+        def launch_prefix(options)
+          return [] if options[:use_stream]
+
+          %W(#{options[:socket_vmnet_client]} #{options[:socket_vmnet_socket]})
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-qemu/network.rb

@@ -2,6 +2,7 @@ require_relative "network/base"
 require_relative "network/vmnet"
 require_relative "network/tap"
 require_relative "network/socket"
+require_relative "network/socket_vmnet"
 
 module VagrantPlugins
   module QEMU
@@ -9,7 +10,7 @@ module VagrantPlugins
       # Select the appropriate network backend based on net_mode and platform.
       #
       # @param net_mode [Symbol] :auto, :vmnet_shared, :vmnet_host,
-      #   :vmnet_bridged, :tap, :socket
+      #   :vmnet_bridged, :tap, :socket, :socket_vmnet
       # @return [Base] a network backend instance
       def self.backend_for(net_mode)
         case net_mode
@@ -19,6 +20,8 @@ module VagrantPlugins
           Tap.new
         when :socket
           Socket.new
+        when :socket_vmnet
+          SocketVmnet.new
         when :auto
           auto_detect
         else
@@ -39,6 +42,34 @@ module VagrantPlugins
         end
       end
 
+      # Whether the QEMU binary has the native `stream` netdev (QEMU >= 7.2),
+      # so socket_vmnet can connect to the daemon's unix socket directly
+      # instead of going through the socket_vmnet_client wrapper.
+      #
+      # Probes `<qemu> -M none -netdev help` and looks for a `stream` line on
+      # stdout. Cached per binary.
+      #
+      # Tri-state so the driver can honor the design's fallback direction:
+      #   true  -- probe ran, stream present  -> use stream
+      #   false -- probe ran, stream absent    -> use the wrapper (old QEMU)
+      #   nil   -- probe could not run (rare)  -> driver defaults to stream
+      #
+      # @param qemu_binary [String] path/name of the qemu-system-* binary
+      # @return [Boolean, nil]
+      def self.qemu_supports_stream?(qemu_binary)
+        @stream_support ||= {}
+        return @stream_support[qemu_binary] if @stream_support.key?(qemu_binary)
+
+        result =
+          begin
+            out = ::Vagrant::Util::Subprocess.execute(qemu_binary, "-M", "none", "-netdev", "help")
+            out.exit_code == 0 ? out.stdout.lines.any? { |l| l.strip == "stream" } : nil
+          rescue StandardError
+            nil
+          end
+        @stream_support[qemu_binary] = result
+      end
+
       # Generate a deterministic MAC address from vm_id and NIC index.
       # Uses 52:54:00 prefix (QEMU's OUI).
       #

data/lib/vagrant-qemu/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module QEMU
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/locales/en.yml

@@ -84,3 +84,24 @@ en:
 
         The machine ID has been preserved. Fix the underlying issue and
         run `vagrant destroy` again.
+      socket_vmnet_not_macos: |-
+        net_mode = :socket_vmnet is only supported on macOS (it relies on
+        the socket_vmnet daemon and vmnet.framework).
+      socket_vmnet_socket_not_found: |-
+        The socket_vmnet daemon socket was not found:
+
+          %{socket}
+
+        Install and start the daemon first, e.g.:
+          brew install socket_vmnet
+          sudo brew services start socket_vmnet
+
+        Or point qe.socket_vmnet_socket at the daemon's socket path.
+      socket_vmnet_client_not_found: |-
+        This QEMU lacks the native `stream` netdev (QEMU < 7.2), so the
+        socket_vmnet_client wrapper is required but was not found:
+
+          %{client}
+
+        Install socket_vmnet (which ships the client), upgrade QEMU to >= 7.2,
+        or point qe.socket_vmnet_client at the wrapper binary.

data/spec/e2e/helper.rb

@@ -130,7 +130,7 @@ RSpec.configure do |config|
   # e2e runs the INSTALLED plugin (see note above) — fail fast when it
   # doesn't match the source tree, instead of silently testing a stale gem.
   config.before(:suite) do
-    next unless ENV["TEST_QEMU"] || ENV["TEST_VMNET"]
+    next unless ENV["TEST_QEMU"] || ENV["TEST_VMNET"] || ENV["TEST_SOCKET_VMNET"]
 
     require "vagrant-qemu/version"
     expected = VagrantPlugins::QEMU::VERSION

data/spec/e2e/socket_vmnet_spec.rb

@@ -0,0 +1,127 @@
+require_relative "helper"
+
+# Requires the socket_vmnet daemon running (no sudo for vagrant itself):
+#   brew install socket_vmnet && sudo brew services start socket_vmnet
+# Run with: TEST_SOCKET_VMNET=1 bundle exec rspec spec/e2e/socket_vmnet_spec.rb
+describe "socket_vmnet advanced networking end-to-end", :requires_socket_vmnet do
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @work_dir = dir.join("project")
+      FileUtils.mkdir_p(@work_dir)
+      example.run
+      vagrant_destroy(@work_dir) rescue nil
+    end
+  end
+
+  it "VM gets the configured static IP (no sudo)" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box_cloudinit}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.network "private_network", ip: "192.168.105.10"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+          qe.advanced_network = true
+          qe.net_mode = :socket_vmnet
+        end
+      end
+    RUBY
+
+    vagrant_up(@work_dir)
+    result = vagrant_ssh(@work_dir, command: "ip addr show")
+    expect(result[:stdout]).to include("192.168.105.10")
+  end
+
+  it "host can ping the VM IP" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box_cloudinit}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.network "private_network", ip: "192.168.105.11"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+          qe.advanced_network = true
+          qe.net_mode = :socket_vmnet
+        end
+      end
+    RUBY
+
+    vagrant_up(@work_dir)
+    `ping -c 1 -t 5 192.168.105.11 2>&1`
+    expect($?.exitstatus).to eq 0
+  end
+
+  it "two VMs can communicate via the socket_vmnet private network" do
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.define "vm1" do |c|
+          c.vm.box = "#{test_box_cloudinit}"
+          c.vm.box_check_update = false
+          c.vm.synced_folder ".", "/vagrant", disabled: true
+          c.vm.network "private_network", ip: "192.168.105.20"
+          c.vm.provider "qemu" do |qe|
+            qe.memory = "2G"
+            qe.advanced_network = true
+            qe.net_mode = :socket_vmnet
+            qe.ssh_auto_correct = true
+          end
+        end
+
+        config.vm.define "vm2" do |c|
+          c.vm.box = "#{test_box_cloudinit}"
+          c.vm.box_check_update = false
+          c.vm.synced_folder ".", "/vagrant", disabled: true
+          c.vm.network "private_network", ip: "192.168.105.21"
+          c.vm.provider "qemu" do |qe|
+            qe.memory = "2G"
+            qe.advanced_network = true
+            qe.net_mode = :socket_vmnet
+            qe.ssh_auto_correct = true
+          end
+        end
+      end
+    RUBY
+
+    vagrant_up(@work_dir, timeout: 600)
+    result = vagrant_ssh(@work_dir, machine: "vm1", command: "ping -c 1 -W 5 192.168.105.21")
+    expect(result[:exit_code]).to eq 0
+    expect(result[:stdout]).to include(" 0% packet loss")
+  end
+
+  # On QEMU >= 7.2 the plugin picks the stream route; a shim that hides the
+  # `stream` netdev from the probe forces the wrapper route (socket_vmnet_client
+  # + `-netdev socket,fd=3`) so it too gets exercised end-to-end -- in
+  # particular that the fd-3 convention survives the plugin's ChildProcess
+  # launcher. socket_vmnet_client itself connects on whatever fd `socket()`
+  # returns, so this proves nothing extra is leaked into fd 3.
+  it "wrapper route (forced via a no-stream shim) connects over fd 3" do
+    shim = File.expand_path("support/qemu_no_stream_shim.sh", __dir__)
+    File.write(@work_dir.join("Vagrantfile"), <<~RUBY)
+      Vagrant.configure("2") do |config|
+        config.vm.box = "#{test_box_cloudinit}"
+        config.vm.box_check_update = false
+        config.vm.synced_folder ".", "/vagrant", disabled: true
+        config.vm.network "private_network", ip: "192.168.105.13"
+        config.vm.provider "qemu" do |qe|
+          qe.memory = "2G"
+          qe.advanced_network = true
+          qe.net_mode = :socket_vmnet
+          qe.qemu_bin = "#{shim}"
+        end
+      end
+    RUBY
+
+    vagrant_up(@work_dir)
+
+    # The wrapper route was genuinely taken (not stream): the running QEMU
+    # carries the fd-3 socket netdev, not a stream netdev.
+    qemu_args = `ps -Ao args 2>/dev/null`
+    expect(qemu_args).to include("socket,id=net1,fd=3")
+    expect(qemu_args).not_to include("-netdev stream")
+
+    result = vagrant_ssh(@work_dir, command: "ip addr show")
+    expect(result[:stdout]).to include("192.168.105.13")
+  end
+end

data/spec/e2e/support/qemu_no_stream_shim.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# Test shim: forces vagrant-qemu's socket_vmnet backend down the wrapper route
+# on a modern QEMU by hiding the native `stream` netdev from the plugin's probe
+# (`-M none -netdev help`). Every other invocation execs the real QEMU verbatim,
+# so the fd 3 handed in by socket_vmnet_client is preserved into QEMU.
+set -euo pipefail
+REAL="${REAL_QEMU:-$(command -v qemu-system-aarch64 || true)}"
+[ -x "$REAL" ] || REAL=/opt/homebrew/bin/qemu-system-aarch64
+
+if [ "$*" = "-M none -netdev help" ]; then
+  "$REAL" "$@" | grep -v '^stream$'
+  exit 0
+fi
+exec "$REAL" "$@"

data/spec/spec_helper.rb

@@ -33,6 +33,7 @@ RSpec.configure do |config|
   config.order = :defined
   config.filter_run_excluding :requires_qemu unless ENV["TEST_QEMU"]
   config.filter_run_excluding :requires_vmnet unless ENV["TEST_VMNET"]
+  config.filter_run_excluding :requires_socket_vmnet unless ENV["TEST_SOCKET_VMNET"]
 end
 
 # Helper to create a temporary directory that is cleaned up after the test

data/spec/unit/config_spec.rb

@@ -140,4 +140,38 @@ describe VagrantPlugins::QEMU::Config do
       expect(config.net_mode).to eq :vmnet_shared
     end
   end
+
+  describe "socket_vmnet paths" do
+    it "defaults to Apple Silicon Homebrew prefix when HOMEBREW_PREFIX is unset" do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with("HOMEBREW_PREFIX").and_return(nil)
+      config = finalized(host_arch: "aarch64", host_accel: "hvf")
+      expect(config.socket_vmnet_socket).to eq "/opt/homebrew/var/run/socket_vmnet"
+      expect(config.socket_vmnet_client).to eq "/opt/homebrew/opt/socket_vmnet/bin/socket_vmnet_client"
+    end
+
+    it "defaults to Intel Homebrew prefix when HOMEBREW_PREFIX is unset" do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with("HOMEBREW_PREFIX").and_return(nil)
+      config = finalized(host_arch: "x86_64", host_accel: "hvf")
+      expect(config.socket_vmnet_socket).to eq "/usr/local/var/run/socket_vmnet"
+    end
+
+    it "derives from HOMEBREW_PREFIX when set" do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with("HOMEBREW_PREFIX").and_return("/opt/hb")
+      config = finalized(host_arch: "aarch64", host_accel: "hvf")
+      expect(config.socket_vmnet_socket).to eq "/opt/hb/var/run/socket_vmnet"
+      expect(config.socket_vmnet_client).to eq "/opt/hb/opt/socket_vmnet/bin/socket_vmnet_client"
+    end
+
+    it "preserves user-specified paths" do
+      config = described_class.new
+      config.socket_vmnet_socket = "/tmp/sv.sock"
+      config.socket_vmnet_client = "/tmp/sv_client"
+      config.finalize!
+      expect(config.socket_vmnet_socket).to eq "/tmp/sv.sock"
+      expect(config.socket_vmnet_client).to eq "/tmp/sv_client"
+    end
+  end
 end

data/spec/unit/driver/start_cmd_socket_vmnet_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+
+describe VagrantPlugins::QEMU::Driver, "start command line (socket_vmnet)" do
+  let(:vm_id) { "vq_svtest00042" }
+
+  around(:each) do |example|
+    with_temp_dir do |dir|
+      @data_dir = dir.join("data")
+      @tmp_base = dir.join("tmp")
+      FileUtils.mkdir_p(@data_dir)
+      FileUtils.mkdir_p(@tmp_base)
+
+      id_dir = @data_dir.join(vm_id)
+      FileUtils.mkdir_p(id_dir)
+      FileUtils.touch(id_dir.join("linked-box.img"))
+      FileUtils.touch(id_dir.join("edk2-aarch64-code.fd"))
+      FileUtils.touch(id_dir.join("edk2-arm-vars.fd"))
+
+      # Real socket + client files so File.exist?/executable? preconditions pass.
+      @sock = @data_dir.join("socket_vmnet").to_s
+      FileUtils.touch(@sock)
+      @client = @data_dir.join("socket_vmnet_client").to_s
+      FileUtils.touch(@client)
+      File.chmod(0o755, @client)
+
+      example.run
+    end
+  end
+
+  subject { described_class.new(vm_id, @data_dir, @tmp_base) }
+
+  let(:base_options) do
+    {
+      ssh_host: "127.0.0.1", ssh_port: 50022,
+      arch: "aarch64", machine: "virt,accel=hvf,highmem=on",
+      cpu: "host", smp: "2", memory: "4G",
+      net_device: "virtio-net-device", drive_interface: "virtio",
+      qemu_bin: nil, extra_qemu_args: [], extra_netdev_args: nil,
+      extra_drive_args: nil, ports: [], control_port: nil,
+      debug_port: nil, no_daemonize: false, firmware_format: "raw",
+      other_default: %w(-parallel null -monitor none -display none -vga none),
+      extra_image_opts: nil,
+      advanced_network: true, net_mode: :socket_vmnet,
+      private_networks: [{ ip: "192.168.105.10", netmask: "255.255.255.0" }],
+      vmnet_interface: "en0", tap_device: nil, mcast_addr: nil,
+      socket_vmnet_socket: nil, socket_vmnet_client: nil,
+    }
+  end
+
+  before do
+    @captured_cmd = nil
+    allow(subject).to receive(:execute) do |*cmd, **opts|
+      @captured_cmd = cmd
+      ""
+    end
+    allow(subject).to receive(:running?).and_return(false)
+    # qemu binary resolves; client path is checked via File.executable? (Which -> nil).
+    allow(Vagrant::Util::Which).to receive(:which).and_return(nil)
+    allow(Vagrant::Util::Which).to receive(:which)
+      .with("qemu-system-aarch64").and_return("/usr/bin/qemu-system-aarch64")
+  end
+
+  def options(overrides = {})
+    base_options.merge(socket_vmnet_socket: @sock, socket_vmnet_client: @client).merge(overrides)
+  end
+
+  context "stream route (QEMU supports stream)" do
+    before { allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(true) }
+
+    it "attaches NIC 1 to the daemon socket via a native stream netdev" do
+      subject.start(options)
+      cmd_str = @captured_cmd.join(" ")
+      expect(cmd_str).to include("-netdev stream,id=net1,server=off,addr.type=unix,addr.path=#{@sock}")
+    end
+
+    it "does not wrap qemu (command still begins with the qemu binary)" do
+      subject.start(options)
+      expect(@captured_cmd.first).to eq "qemu-system-aarch64"
+    end
+
+    it "keeps NIC 0 user-mode with SSH hostfwd" do
+      subject.start(options)
+      expect(@captured_cmd.join(" ")).to include("-netdev user,id=net0,hostfwd=tcp::50022-:22")
+    end
+  end
+
+  context "wrapper route (QEMU lacks stream)" do
+    before { allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(false) }
+
+    it "prepends the socket_vmnet_client wrapper with the socket path" do
+      subject.start(options)
+      expect(@captured_cmd[0, 3]).to eq [@client, @sock, "qemu-system-aarch64"]
+    end
+
+    it "attaches NIC 1 via a socket netdev on fd 3" do
+      subject.start(options)
+      expect(@captured_cmd.join(" ")).to include("-netdev socket,id=net1,fd=3")
+    end
+  end
+
+  context "probe could not run (nil) -> optimistic stream" do
+    before { allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(nil) }
+
+    it "uses the stream route and no wrapper" do
+      subject.start(options)
+      expect(@captured_cmd.first).to eq "qemu-system-aarch64"
+      expect(@captured_cmd.join(" ")).to include("-netdev stream,id=net1")
+    end
+  end
+
+  context "gating: net_mode set but advanced_network off" do
+    it "does not wrap qemu and does not add NIC 1 (matches pre-existing warn behavior)" do
+      # No probe should even happen; single-NIC user-mode path.
+      expect(VagrantPlugins::QEMU::Network).not_to receive(:qemu_supports_stream?)
+      subject.start(options(advanced_network: false))
+      cmd_str = @captured_cmd.join(" ")
+      expect(@captured_cmd.first).to eq "qemu-system-aarch64"
+      expect(cmd_str).not_to include("netdev=net1")
+      expect(cmd_str).not_to include("-netdev stream")
+      expect(cmd_str).not_to include("fd=3")
+    end
+  end
+
+  context "preconditions (fail-fast)" do
+    it "raises when the daemon socket is missing" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(true)
+      expect { subject.start(options(socket_vmnet_socket: "/nonexistent/sock")) }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetSocketNotFound)
+    end
+
+    it "raises on the wrapper route when the client is missing" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(false)
+      expect { subject.start(options(socket_vmnet_client: "/nonexistent/client")) }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetClientNotFound)
+    end
+
+    it "raises on non-macOS hosts" do
+      allow(RbConfig::CONFIG).to receive(:[]).and_call_original
+      allow(RbConfig::CONFIG).to receive(:[]).with("host_os").and_return("linux-gnu")
+      expect { subject.start(options) }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetNotMacos)
+    end
+  end
+end

data/spec/unit/network/backend_for_spec.rb

@@ -21,6 +21,10 @@ describe VagrantPlugins::QEMU::Network, ".backend_for" do
     expect(described_class.backend_for(:socket)).to be_a(VagrantPlugins::QEMU::Network::Socket)
   end
 
+  it "returns SocketVmnet for :socket_vmnet" do
+    expect(described_class.backend_for(:socket_vmnet)).to be_a(VagrantPlugins::QEMU::Network::SocketVmnet)
+  end
+
   it "raises ConfigError for unknown net_mode" do
     expect { described_class.backend_for(:bogus) }.to raise_error(VagrantPlugins::QEMU::Errors::ConfigError)
   end

data/spec/unit/network/socket_vmnet_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe VagrantPlugins::QEMU::Network::SocketVmnet do
+  subject { described_class.new }
+
+  let(:sock) { "/opt/homebrew/var/run/socket_vmnet" }
+  let(:client) { "/opt/homebrew/opt/socket_vmnet/bin/socket_vmnet_client" }
+
+  context "stream route (use_stream: true)" do
+    let(:opts) { { use_stream: true, socket_vmnet_socket: sock, socket_vmnet_client: client } }
+
+    it "builds a native stream netdev connecting to the daemon socket" do
+      expect(subject.build_netdev_args("net1", opts))
+        .to eq %W(-netdev stream,id=net1,server=off,addr.type=unix,addr.path=#{sock})
+    end
+
+    it "needs no launch wrapper" do
+      expect(subject.launch_prefix(opts)).to eq []
+    end
+  end
+
+  context "wrapper route (use_stream: false)" do
+    let(:opts) { { use_stream: false, socket_vmnet_socket: sock, socket_vmnet_client: client } }
+
+    it "builds a socket netdev on fd 3" do
+      expect(subject.build_netdev_args("net1", opts)).to eq %w(-netdev socket,id=net1,fd=3)
+    end
+
+    it "prepends the socket_vmnet_client wrapper with the socket path" do
+      expect(subject.launch_prefix(opts)).to eq [client, sock]
+    end
+  end
+
+  it "never requires sudo (the daemon holds the root vmnet membership)" do
+    expect(subject.requires_sudo?).to eq false
+  end
+
+  describe "#preflight!" do
+    around(:each) { |ex| with_temp_dir { |dir| @dir = dir; ex.run } }
+
+    def opts(overrides = {})
+      sock = @dir.join("sock").to_s
+      FileUtils.touch(sock)
+      client = @dir.join("client").to_s
+      FileUtils.touch(client)
+      File.chmod(0o755, client)
+      { socket_vmnet_socket: sock, socket_vmnet_client: client }.merge(overrides)
+    end
+
+    before do
+      allow(RbConfig::CONFIG).to receive(:[]).and_call_original
+      allow(RbConfig::CONFIG).to receive(:[]).with("host_os").and_return("darwin23")
+    end
+
+    it "sets use_stream=true when the probe reports stream" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(true)
+      o = opts
+      subject.preflight!(o, "qemu-x")
+      expect(o[:use_stream]).to eq true
+    end
+
+    it "sets use_stream=false when the probe definitively lacks stream" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(false)
+      o = opts
+      subject.preflight!(o, "qemu-x")
+      expect(o[:use_stream]).to eq false
+    end
+
+    it "defaults use_stream=true when the probe is unknown (nil)" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(nil)
+      o = opts
+      subject.preflight!(o, "qemu-x")
+      expect(o[:use_stream]).to eq true
+    end
+
+    it "raises on non-macOS hosts" do
+      allow(RbConfig::CONFIG).to receive(:[]).with("host_os").and_return("linux-gnu")
+      expect { subject.preflight!(opts, "qemu-x") }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetNotMacos)
+    end
+
+    it "raises when the daemon socket is missing" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(true)
+      expect { subject.preflight!(opts(socket_vmnet_socket: "/nope/sock"), "qemu-x") }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetSocketNotFound)
+    end
+
+    it "raises on the wrapper route when the client is missing" do
+      allow(VagrantPlugins::QEMU::Network).to receive(:qemu_supports_stream?).and_return(false)
+      allow(::Vagrant::Util::Which).to receive(:which).and_return(nil)
+      expect { subject.preflight!(opts(socket_vmnet_client: "/nope/client"), "qemu-x") }
+        .to raise_error(VagrantPlugins::QEMU::Errors::SocketVmnetClientNotFound)
+    end
+  end
+end
+
+describe VagrantPlugins::QEMU::Network::Base do
+  it "#launch_prefix defaults to an empty prefix (other backends launch qemu directly)" do
+    expect(described_class.new.launch_prefix({})).to eq []
+    expect(VagrantPlugins::QEMU::Network::Vmnet.new.launch_prefix({})).to eq []
+  end
+
+  it "#preflight! is a no-op by default (other backends need no preconditions)" do
+    o = { some: "opt" }
+    expect { described_class.new.preflight!(o, "qemu-x") }.not_to raise_error
+    expect(o).to eq({ some: "opt" })
+  end
+end
+
+describe VagrantPlugins::QEMU::Network, ".qemu_supports_stream?" do
+  # Reset the memoized cache between examples.
+  before { described_class.instance_variable_set(:@stream_support, nil) }
+
+  def stub_probe(stdout:, exit_code: 0)
+    result = ::Vagrant::Util::Subprocess::Result.new(exit_code, stdout, "")
+    allow(::Vagrant::Util::Subprocess).to receive(:execute)
+      .with("qemu-x", "-M", "none", "-netdev", "help").and_return(result)
+  end
+
+  it "is true when the netdev list contains a stream line" do
+    stub_probe(stdout: "socket\nstream\ndgram\nuser\n")
+    expect(described_class.qemu_supports_stream?("qemu-x")).to eq true
+  end
+
+  it "is false when the list lacks stream (old QEMU)" do
+    stub_probe(stdout: "socket\nuser\ntap\n")
+    expect(described_class.qemu_supports_stream?("qemu-x")).to eq false
+  end
+
+  it "is nil (unknown) when the probe exits non-zero" do
+    stub_probe(stdout: "stream\n", exit_code: 1)
+    expect(described_class.qemu_supports_stream?("qemu-x")).to be_nil
+  end
+
+  it "is nil (not an exception) when the probe cannot run" do
+    allow(::Vagrant::Util::Subprocess).to receive(:execute).and_raise(StandardError.new("boom"))
+    expect(described_class.qemu_supports_stream?("qemu-x")).to be_nil
+  end
+
+  it "caches the result per binary (probes once)" do
+    stub_probe(stdout: "stream\n")
+    described_class.qemu_supports_stream?("qemu-x")
+    described_class.qemu_supports_stream?("qemu-x")
+    expect(::Vagrant::Util::Subprocess).to have_received(:execute).once
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-qemu
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - ppggff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-11 00:00:00.000000000 Z
+date: 2026-07-21 00:00:00.000000000 Z
 dependencies: []
 description: Enables Vagrant to manage machines with QEMU.
 email: pgf00a@gmail.com
@@ -46,6 +46,7 @@ files:
 - lib/vagrant-qemu/network.rb
 - lib/vagrant-qemu/network/base.rb
 - lib/vagrant-qemu/network/socket.rb
+- lib/vagrant-qemu/network/socket_vmnet.rb
 - lib/vagrant-qemu/network/tap.rb
 - lib/vagrant-qemu/network/vmnet.rb
 - lib/vagrant-qemu/plugin.rb
@@ -68,6 +69,8 @@ files:
 - spec/e2e/reload_spec.rb
 - spec/e2e/smoke_spec.rb
 - spec/e2e/socket_network_spec.rb
+- spec/e2e/socket_vmnet_spec.rb
+- spec/e2e/support/qemu_no_stream_shim.sh
 - spec/spec_helper.rb
 - spec/unit/action/cloud_init_network_spec.rb
 - spec/unit/action/destroy_spec.rb
@@ -87,6 +90,7 @@ files:
 - spec/unit/driver/ssh_port_spec.rb
 - spec/unit/driver/start_cmd_advanced_spec.rb
 - spec/unit/driver/start_cmd_order_spec.rb
+- spec/unit/driver/start_cmd_socket_vmnet_spec.rb
 - spec/unit/driver/start_cmd_spec.rb
 - spec/unit/driver/start_edge_cases_spec.rb
 - spec/unit/driver/state_spec.rb
@@ -95,6 +99,7 @@ files:
 - spec/unit/network/build_network_config_spec.rb
 - spec/unit/network/generate_mac_spec.rb
 - spec/unit/network/socket_spec.rb
+- spec/unit/network/socket_vmnet_spec.rb
 - spec/unit/network/tap_spec.rb
 - spec/unit/network/vmnet_spec.rb
 - vagrant-qemu.gemspec