chef 12.7.2 → 12.8.1

data/lib/chef/win32/memory.rb

@@ -1,101 +1,101 @@
-#
-# Author:: John Keiser (<jkeiser@chef.io>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/win32/error"
-require "chef/win32/api/memory"
-
-class Chef
-  module ReservedNames::Win32
-    class Memory
-      include Chef::ReservedNames::Win32::API::Memory
-      extend Chef::ReservedNames::Win32::API::Memory
-
-      # local_alloc(length[, flags]) [BLOCK]
-      # Allocates memory using LocalAlloc
-      # If BLOCK is specified, the memory will be passed
-      # to the block and freed afterwards.
-      def self.local_alloc(length, flags = LPTR, &block)
-        result = LocalAlloc(flags, length)
-        if result.null?
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-        # If a block is passed, handle freeing the memory at the end
-        if block != nil
-          begin
-            yield result
-          ensure
-            local_free(result)
-          end
-        else
-          result
-        end
-      end
-
-      # local_discard(pointer)
-      # Discard memory.  Equivalent to local_realloc(pointer, 0)
-      def self.local_discard(pointer)
-        local_realloc(pointer, 0, LMEM_MOVEABLE)
-      end
-
-      # local_flags(pointer)
-      # Get lock count and Windows flags for local_alloc allocated memory.
-      # Use: flags, lock_count = local_flags(pointer)
-      def self.local_flags(pointer)
-        result = LocalFlags(pointer)
-        if result == LMEM_INVALID_HANDLE
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-        [ result & ~LMEM_LOCKCOUNT, result & LMEM_LOCKCOUNT ]
-      end
-
-      # local_free(pointer)
-      # Free memory allocated using local_alloc
-      def self.local_free(pointer)
-        result = LocalFree(pointer)
-        if !result.null?
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-      end
-
-      # local_realloc(pointer, size[, flags])
-      # Resizes memory allocated using LocalAlloc.
-      def self.local_realloc(pointer, size, flags = LMEM_MOVEABLE | LMEM_ZEROINIT)
-        result = LocalReAlloc(pointer, size, flags)
-        if result.null?
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-        result
-      end
-
-      # local_size(pointer)
-      # Gets the size of memory allocated using LocalAlloc.
-      def self.local_size(pointer)
-        result = LocalSize(pointer)
-        if result == 0
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-        result
-      end
-
-      def self.local_free_finalizer(pointer)
-        proc { local_free(pointer) }
-      end
-
-    end
-  end
-end
+#
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/win32/error"
+require "chef/win32/api/memory"
+
+class Chef
+  module ReservedNames::Win32
+    class Memory
+      include Chef::ReservedNames::Win32::API::Memory
+      extend Chef::ReservedNames::Win32::API::Memory
+
+      # local_alloc(length[, flags]) [BLOCK]
+      # Allocates memory using LocalAlloc
+      # If BLOCK is specified, the memory will be passed
+      # to the block and freed afterwards.
+      def self.local_alloc(length, flags = LPTR, &block)
+        result = LocalAlloc(flags, length)
+        if result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        # If a block is passed, handle freeing the memory at the end
+        if block != nil
+          begin
+            yield result
+          ensure
+            local_free(result)
+          end
+        else
+          result
+        end
+      end
+
+      # local_discard(pointer)
+      # Discard memory.  Equivalent to local_realloc(pointer, 0)
+      def self.local_discard(pointer)
+        local_realloc(pointer, 0, LMEM_MOVEABLE)
+      end
+
+      # local_flags(pointer)
+      # Get lock count and Windows flags for local_alloc allocated memory.
+      # Use: flags, lock_count = local_flags(pointer)
+      def self.local_flags(pointer)
+        result = LocalFlags(pointer)
+        if result == LMEM_INVALID_HANDLE
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        [ result & ~LMEM_LOCKCOUNT, result & LMEM_LOCKCOUNT ]
+      end
+
+      # local_free(pointer)
+      # Free memory allocated using local_alloc
+      def self.local_free(pointer)
+        result = LocalFree(pointer)
+        if !result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      # local_realloc(pointer, size[, flags])
+      # Resizes memory allocated using LocalAlloc.
+      def self.local_realloc(pointer, size, flags = LMEM_MOVEABLE | LMEM_ZEROINIT)
+        result = LocalReAlloc(pointer, size, flags)
+        if result.null?
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result
+      end
+
+      # local_size(pointer)
+      # Gets the size of memory allocated using LocalAlloc.
+      def self.local_size(pointer)
+        result = LocalSize(pointer)
+        if result == 0
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+        result
+      end
+
+      def self.local_free_finalizer(pointer)
+        proc { local_free(pointer) }
+      end
+
+    end
+  end
+end

data/lib/chef/win32/mutex.rb

@@ -1,116 +1,116 @@
-#
-# Author:: Serdar Sutay (<serdar@chef.io>)
-# Copyright:: Copyright 2013-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/win32/api/synchronization"
-require "chef/win32/unicode"
-
-class Chef
-  module ReservedNames::Win32
-    class Mutex
-      include Chef::ReservedNames::Win32::API::Synchronization
-
-      def initialize(name)
-        @name = name
-        create_system_mutex
-      end
-
-      attr_reader :handle
-      attr_reader :name
-
-      #####################################################
-      # Attempts to grab the mutex.
-      # Returns true if the mutex is grabbed or if it's already
-      # owned; false otherwise.
-      def test
-        WaitForSingleObject(handle, 0) == WAIT_OBJECT_0
-      end
-
-      #####################################################
-      # Attempts to grab the mutex and waits until it is acquired.
-      def wait
-        loop do
-          wait_result = WaitForSingleObject(handle, 1000)
-          case wait_result
-          when WAIT_TIMEOUT
-            # We are periodically waking up in order to give ruby a
-            # chance to process any signal it got while we were
-            # sleeping. This condition shouldn't contain any logic
-            # other than sleeping.
-            sleep 0.1
-          when WAIT_ABANDONED
-            # Previous owner of the mutex died before it can release the
-            # mutex. Log a warning and continue.
-            Chef::Log.debug "Existing owner of the mutex exited prematurely."
-            break
-          when WAIT_OBJECT_0
-            # Mutex is successfully acquired.
-            break
-          else
-            Chef::Log.error("Failed to acquire system mutex '#{name}'. Return code: #{wait_result}")
-            Chef::ReservedNames::Win32::Error.raise!
-          end
-        end
-      end
-
-      #####################################################
-      # Releaes the mutex
-      def release
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms685066(v=vs.85).aspx
-        # Note that release method needs to be called more than once
-        # if mutex is acquired more than once.
-        unless ReleaseMutex(handle)
-          # Don't fail things in here if we can't release the mutex.
-          # Because it will be automatically released when the owner
-          # of the process goes away and this class is only being used
-          # to synchronize chef-clients runs on a node.
-          Chef::Log.error("Can not release mutex '#{name}'. This might cause issues \
-if other threads attempt to acquire the mutex.")
-          Chef::ReservedNames::Win32::Error.raise!
-        end
-      end
-
-      private
-
-      def create_system_mutex
-        # First check if there exists a mutex in the system with the
-        # given name. We need only synchronize rights if a mutex is
-        # already created.
-        # InheritHandle is set to true so that subprocesses can
-        # inherit the ownership of the mutex.
-        @handle = OpenMutexW(SYNCHRONIZE, true, name.to_wstring)
-
-        if @handle == 0
-          # Mutext doesn't exist so create one.
-          # In the initial creation of the mutex initial_owner is set to
-          # false so that mutex will not be acquired until someone calls
-          # acquire.
-          # In order to call "*W" windows apis, strings needs to be
-          # encoded as wide strings.
-          @handle = CreateMutexW(nil, false, name.to_wstring)
-
-          # Looks like we can't create the mutex for some reason.
-          # Fail early.
-          if @handle == 0
-            Chef::Log.error("Failed to create system mutex with name'#{name}'")
-            Chef::ReservedNames::Win32::Error.raise!
-          end
-        end
-      end
-    end
-  end
-end
+#
+# Author:: Serdar Sutay (<serdar@chef.io>)
+# Copyright:: Copyright 2013-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/win32/api/synchronization"
+require "chef/win32/unicode"
+
+class Chef
+  module ReservedNames::Win32
+    class Mutex
+      include Chef::ReservedNames::Win32::API::Synchronization
+
+      def initialize(name)
+        @name = name
+        create_system_mutex
+      end
+
+      attr_reader :handle
+      attr_reader :name
+
+      #####################################################
+      # Attempts to grab the mutex.
+      # Returns true if the mutex is grabbed or if it's already
+      # owned; false otherwise.
+      def test
+        WaitForSingleObject(handle, 0) == WAIT_OBJECT_0
+      end
+
+      #####################################################
+      # Attempts to grab the mutex and waits until it is acquired.
+      def wait
+        loop do
+          wait_result = WaitForSingleObject(handle, 1000)
+          case wait_result
+          when WAIT_TIMEOUT
+            # We are periodically waking up in order to give ruby a
+            # chance to process any signal it got while we were
+            # sleeping. This condition shouldn't contain any logic
+            # other than sleeping.
+            sleep 0.1
+          when WAIT_ABANDONED
+            # Previous owner of the mutex died before it can release the
+            # mutex. Log a warning and continue.
+            Chef::Log.debug "Existing owner of the mutex exited prematurely."
+            break
+          when WAIT_OBJECT_0
+            # Mutex is successfully acquired.
+            break
+          else
+            Chef::Log.error("Failed to acquire system mutex '#{name}'. Return code: #{wait_result}")
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+        end
+      end
+
+      #####################################################
+      # Releaes the mutex
+      def release
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms685066(v=vs.85).aspx
+        # Note that release method needs to be called more than once
+        # if mutex is acquired more than once.
+        unless ReleaseMutex(handle)
+          # Don't fail things in here if we can't release the mutex.
+          # Because it will be automatically released when the owner
+          # of the process goes away and this class is only being used
+          # to synchronize chef-clients runs on a node.
+          Chef::Log.error("Can not release mutex '#{name}'. This might cause issues \
+if other threads attempt to acquire the mutex.")
+          Chef::ReservedNames::Win32::Error.raise!
+        end
+      end
+
+      private
+
+      def create_system_mutex
+        # First check if there exists a mutex in the system with the
+        # given name. We need only synchronize rights if a mutex is
+        # already created.
+        # InheritHandle is set to true so that subprocesses can
+        # inherit the ownership of the mutex.
+        @handle = OpenMutexW(SYNCHRONIZE, true, name.to_wstring)
+
+        if @handle == 0
+          # Mutext doesn't exist so create one.
+          # In the initial creation of the mutex initial_owner is set to
+          # false so that mutex will not be acquired until someone calls
+          # acquire.
+          # In order to call "*W" windows apis, strings needs to be
+          # encoded as wide strings.
+          @handle = CreateMutexW(nil, false, name.to_wstring)
+
+          # Looks like we can't create the mutex for some reason.
+          # Fail early.
+          if @handle == 0
+            Chef::Log.error("Failed to create system mutex with name'#{name}'")
+            Chef::ReservedNames::Win32::Error.raise!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/win32/net.rb

@@ -1,311 +1,311 @@
-#
-# Author:: Jay Mundrawala(<jdm@chef.io>)
-# Copyright:: Copyright 2015-2016, Chef Software
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/win32/api/net"
-require "chef/win32/error"
-require "chef/mixin/wide_string"
-
-class Chef
-  module ReservedNames::Win32
-    class Net
-      include Chef::ReservedNames::Win32::API::Error
-      extend Chef::ReservedNames::Win32::API::Error
-
-      include Chef::ReservedNames::Win32::API::Net
-      extend Chef::ReservedNames::Win32::API::Net
-
-      include Chef::Mixin::WideString
-      extend Chef::Mixin::WideString
-
-      def self.default_user_info_3
-        ui3 = USER_INFO_3.new.tap do |s|
-          { usri3_name: nil,
-            usri3_password: nil,
-            usri3_password_age: 0,
-            usri3_priv: 0,
-            usri3_home_dir: nil,
-            usri3_comment: nil,
-            usri3_flags: UF_SCRIPT | UF_DONT_EXPIRE_PASSWD | UF_NORMAL_ACCOUNT,
-            usri3_script_path: nil,
-            usri3_auth_flags: 0,
-            usri3_full_name: nil,
-            usri3_usr_comment: nil,
-            usri3_parms: nil,
-            usri3_workstations: nil,
-            usri3_last_logon: 0,
-            usri3_last_logoff: 0,
-            usri3_acct_expires: -1,
-            usri3_max_storage: -1,
-            usri3_units_per_week: 0,
-            usri3_logon_hours: nil,
-            usri3_bad_pw_count: 0,
-            usri3_num_logons: 0,
-            usri3_logon_server: nil,
-            usri3_country_code: 0,
-            usri3_code_page: 0,
-            usri3_user_id: 0,
-            usri3_primary_group_id: DOMAIN_GROUP_RID_USERS,
-            usri3_profile: nil,
-            usri3_home_dir_drive: nil,
-            usri3_password_expired: 0,
-          }.each do |(k, v)|
-            s.set(k, v)
-          end
-        end
-      end
-
-      def self.net_local_group_add(server_name, group_name)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        buf = LOCALGROUP_INFO_0.new
-        buf[:lgrpi0_name] = FFI::MemoryPointer.from_string(group_name)
-
-        rc = NetLocalGroupAdd(server_name, 0, buf, nil)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_local_group_del(server_name, group_name)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        rc = NetLocalGroupDel(server_name, group_name)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_local_group_get_members(server_name, group_name)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        buf = FFI::MemoryPointer.new(:pointer)
-        entries_read_ptr = FFI::MemoryPointer.new(:long)
-        total_read_ptr = FFI::MemoryPointer.new(:long)
-        resume_handle_ptr = FFI::MemoryPointer.new(:pointer)
-
-        rc = ERROR_MORE_DATA
-        group_members = []
-        while rc == ERROR_MORE_DATA
-          rc = NetLocalGroupGetMembers(
-            server_name, group_name, 0, buf, -1,
-            entries_read_ptr, total_read_ptr, resume_handle_ptr
-          )
-
-          nread = entries_read_ptr.read_long
-          nread.times do |i|
-            member = LOCALGROUP_MEMBERS_INFO_0.new(buf.read_pointer +
-                                                   (i * LOCALGROUP_MEMBERS_INFO_0.size))
-            member_sid = Chef::ReservedNames::Win32::Security::SID.new(member[:lgrmi0_sid])
-            group_members << member_sid.to_s
-          end
-          NetApiBufferFree(buf.read_pointer)
-        end
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-
-        group_members
-      end
-
-      def self.net_user_add_l3(server_name, args)
-        buf = default_user_info_3
-
-        args.each do |k, v|
-          buf.set(k, v)
-        end
-
-        server_name = wstring(server_name)
-
-        rc = NetUserAdd(server_name, 3, buf, nil)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_user_get_info_l3(server_name, user_name)
-        server_name = wstring(server_name)
-        user_name = wstring(user_name)
-
-        ui3_p = FFI::MemoryPointer.new(:pointer)
-
-        rc = NetUserGetInfo(server_name, user_name, 3, ui3_p)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-
-        ui3 = USER_INFO_3.new(ui3_p.read_pointer).as_ruby
-
-        rc = NetApiBufferFree(ui3_p.read_pointer)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-
-        ui3
-      end
-
-      def self.net_user_set_info_l3(server_name, user_name, info)
-        buf = default_user_info_3
-
-        info.each do |k, v|
-          buf.set(k, v)
-        end
-
-        server_name = wstring(server_name)
-        user_name = wstring(user_name)
-
-        rc = NetUserSetInfo(server_name, user_name, 3, buf, nil)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_user_del(server_name, user_name)
-        server_name = wstring(server_name)
-        user_name = wstring(user_name)
-
-        rc = NetUserDel(server_name, user_name)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_local_group_add_member(server_name, group_name, domain_user)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-        domain_user = wstring(domain_user)
-
-        buf = LOCALGROUP_MEMBERS_INFO_3.new
-        buf[:lgrmi3_domainandname] = FFI::MemoryPointer.from_string(domain_user)
-
-        rc = NetLocalGroupAddMembers(server_name, group_name, 3, buf, 1)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.members_to_lgrmi3(members)
-        buf = FFI::MemoryPointer.new(LOCALGROUP_MEMBERS_INFO_3, members.size)
-        members.size.times.collect do |i|
-          member_info = LOCALGROUP_MEMBERS_INFO_3.new(
-            buf + i * LOCALGROUP_MEMBERS_INFO_3.size)
-          member_info[:lgrmi3_domainandname] = FFI::MemoryPointer.from_string(wstring(members[i]))
-          member_info
-        end
-      end
-
-      def self.net_local_group_add_members(server_name, group_name, members)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        lgrmi3s = members_to_lgrmi3(members)
-        rc = NetLocalGroupAddMembers(
-          server_name, group_name, 3, lgrmi3s[0], members.size)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_local_group_set_members(server_name, group_name, members)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        lgrmi3s = members_to_lgrmi3(members)
-        rc = NetLocalGroupSetMembers(
-          server_name, group_name, 3, lgrmi3s[0], members.size)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_local_group_del_members(server_name, group_name, members)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        lgrmi3s = members_to_lgrmi3(members)
-        rc = NetLocalGroupDelMembers(
-          server_name, group_name, 3, lgrmi3s[0], members.size)
-
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_use_del(server_name, use_name, force = :use_noforce)
-        server_name = wstring(server_name)
-        use_name = wstring(use_name)
-        force_const = case force
-                      when :use_noforce
-                        USE_NOFORCE
-                      when :use_force
-                        USE_FORCE
-                      when :use_lots_of_force
-                        USE_LOTS_OF_FORCE
-                      else
-                        raise ArgumentError, "force must be one of [:use_noforce, :use_force, or :use_lots_of_force]"
-                      end
-
-        rc = NetUseDel(server_name, use_name, force_const)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-
-      def self.net_use_get_info_l2(server_name, use_name)
-        server_name = wstring(server_name)
-        use_name = wstring(use_name)
-        ui2_p = FFI::MemoryPointer.new(:pointer)
-
-        rc = NetUseGetInfo(server_name, use_name, 2, ui2_p)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-
-        ui2 = USE_INFO_2.new(ui2_p.read_pointer).as_ruby
-        NetApiBufferFree(ui2_p.read_pointer)
-
-        ui2
-      end
-
-      def self.net_use_add_l2(server_name, ui2_hash)
-        server_name = wstring(server_name)
-        group_name = wstring(group_name)
-
-        buf = USE_INFO_2.new
-
-        ui2_hash.each do |(k, v)|
-          buf.set(k, v)
-        end
-
-        rc = NetUseAdd(server_name, 2, buf, nil)
-        if rc != NERR_Success
-          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
-        end
-      end
-    end
-    NetUser = Net # For backwards compatibility
-  end
-end
+#
+# Author:: Jay Mundrawala(<jdm@chef.io>)
+# Copyright:: Copyright 2015-2016, Chef Software
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/win32/api/net"
+require "chef/win32/error"
+require "chef/mixin/wide_string"
+
+class Chef
+  module ReservedNames::Win32
+    class Net
+      include Chef::ReservedNames::Win32::API::Error
+      extend Chef::ReservedNames::Win32::API::Error
+
+      include Chef::ReservedNames::Win32::API::Net
+      extend Chef::ReservedNames::Win32::API::Net
+
+      include Chef::Mixin::WideString
+      extend Chef::Mixin::WideString
+
+      def self.default_user_info_3
+        ui3 = USER_INFO_3.new.tap do |s|
+          { usri3_name: nil,
+            usri3_password: nil,
+            usri3_password_age: 0,
+            usri3_priv: 0,
+            usri3_home_dir: nil,
+            usri3_comment: nil,
+            usri3_flags: UF_SCRIPT | UF_DONT_EXPIRE_PASSWD | UF_NORMAL_ACCOUNT,
+            usri3_script_path: nil,
+            usri3_auth_flags: 0,
+            usri3_full_name: nil,
+            usri3_usr_comment: nil,
+            usri3_parms: nil,
+            usri3_workstations: nil,
+            usri3_last_logon: 0,
+            usri3_last_logoff: 0,
+            usri3_acct_expires: -1,
+            usri3_max_storage: -1,
+            usri3_units_per_week: 0,
+            usri3_logon_hours: nil,
+            usri3_bad_pw_count: 0,
+            usri3_num_logons: 0,
+            usri3_logon_server: nil,
+            usri3_country_code: 0,
+            usri3_code_page: 0,
+            usri3_user_id: 0,
+            usri3_primary_group_id: DOMAIN_GROUP_RID_USERS,
+            usri3_profile: nil,
+            usri3_home_dir_drive: nil,
+            usri3_password_expired: 0,
+          }.each do |(k, v)|
+            s.set(k, v)
+          end
+        end
+      end
+
+      def self.net_local_group_add(server_name, group_name)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        buf = LOCALGROUP_INFO_0.new
+        buf[:lgrpi0_name] = FFI::MemoryPointer.from_string(group_name)
+
+        rc = NetLocalGroupAdd(server_name, 0, buf, nil)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_local_group_del(server_name, group_name)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        rc = NetLocalGroupDel(server_name, group_name)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_local_group_get_members(server_name, group_name)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        buf = FFI::MemoryPointer.new(:pointer)
+        entries_read_ptr = FFI::MemoryPointer.new(:long)
+        total_read_ptr = FFI::MemoryPointer.new(:long)
+        resume_handle_ptr = FFI::MemoryPointer.new(:pointer)
+
+        rc = ERROR_MORE_DATA
+        group_members = []
+        while rc == ERROR_MORE_DATA
+          rc = NetLocalGroupGetMembers(
+            server_name, group_name, 0, buf, -1,
+            entries_read_ptr, total_read_ptr, resume_handle_ptr
+          )
+
+          nread = entries_read_ptr.read_long
+          nread.times do |i|
+            member = LOCALGROUP_MEMBERS_INFO_0.new(buf.read_pointer +
+                                                   (i * LOCALGROUP_MEMBERS_INFO_0.size))
+            member_sid = Chef::ReservedNames::Win32::Security::SID.new(member[:lgrmi0_sid])
+            group_members << member_sid.to_s
+          end
+          NetApiBufferFree(buf.read_pointer)
+        end
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+
+        group_members
+      end
+
+      def self.net_user_add_l3(server_name, args)
+        buf = default_user_info_3
+
+        args.each do |k, v|
+          buf.set(k, v)
+        end
+
+        server_name = wstring(server_name)
+
+        rc = NetUserAdd(server_name, 3, buf, nil)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_user_get_info_l3(server_name, user_name)
+        server_name = wstring(server_name)
+        user_name = wstring(user_name)
+
+        ui3_p = FFI::MemoryPointer.new(:pointer)
+
+        rc = NetUserGetInfo(server_name, user_name, 3, ui3_p)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+
+        ui3 = USER_INFO_3.new(ui3_p.read_pointer).as_ruby
+
+        rc = NetApiBufferFree(ui3_p.read_pointer)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+
+        ui3
+      end
+
+      def self.net_user_set_info_l3(server_name, user_name, info)
+        buf = default_user_info_3
+
+        info.each do |k, v|
+          buf.set(k, v)
+        end
+
+        server_name = wstring(server_name)
+        user_name = wstring(user_name)
+
+        rc = NetUserSetInfo(server_name, user_name, 3, buf, nil)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_user_del(server_name, user_name)
+        server_name = wstring(server_name)
+        user_name = wstring(user_name)
+
+        rc = NetUserDel(server_name, user_name)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_local_group_add_member(server_name, group_name, domain_user)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+        domain_user = wstring(domain_user)
+
+        buf = LOCALGROUP_MEMBERS_INFO_3.new
+        buf[:lgrmi3_domainandname] = FFI::MemoryPointer.from_string(domain_user)
+
+        rc = NetLocalGroupAddMembers(server_name, group_name, 3, buf, 1)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.members_to_lgrmi3(members)
+        buf = FFI::MemoryPointer.new(LOCALGROUP_MEMBERS_INFO_3, members.size)
+        members.size.times.collect do |i|
+          member_info = LOCALGROUP_MEMBERS_INFO_3.new(
+            buf + i * LOCALGROUP_MEMBERS_INFO_3.size)
+          member_info[:lgrmi3_domainandname] = FFI::MemoryPointer.from_string(wstring(members[i]))
+          member_info
+        end
+      end
+
+      def self.net_local_group_add_members(server_name, group_name, members)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        lgrmi3s = members_to_lgrmi3(members)
+        rc = NetLocalGroupAddMembers(
+          server_name, group_name, 3, lgrmi3s[0], members.size)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_local_group_set_members(server_name, group_name, members)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        lgrmi3s = members_to_lgrmi3(members)
+        rc = NetLocalGroupSetMembers(
+          server_name, group_name, 3, lgrmi3s[0], members.size)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_local_group_del_members(server_name, group_name, members)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        lgrmi3s = members_to_lgrmi3(members)
+        rc = NetLocalGroupDelMembers(
+          server_name, group_name, 3, lgrmi3s[0], members.size)
+
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_use_del(server_name, use_name, force = :use_noforce)
+        server_name = wstring(server_name)
+        use_name = wstring(use_name)
+        force_const = case force
+                      when :use_noforce
+                        USE_NOFORCE
+                      when :use_force
+                        USE_FORCE
+                      when :use_lots_of_force
+                        USE_LOTS_OF_FORCE
+                      else
+                        raise ArgumentError, "force must be one of [:use_noforce, :use_force, or :use_lots_of_force]"
+                      end
+
+        rc = NetUseDel(server_name, use_name, force_const)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+
+      def self.net_use_get_info_l2(server_name, use_name)
+        server_name = wstring(server_name)
+        use_name = wstring(use_name)
+        ui2_p = FFI::MemoryPointer.new(:pointer)
+
+        rc = NetUseGetInfo(server_name, use_name, 2, ui2_p)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+
+        ui2 = USE_INFO_2.new(ui2_p.read_pointer).as_ruby
+        NetApiBufferFree(ui2_p.read_pointer)
+
+        ui2
+      end
+
+      def self.net_use_add_l2(server_name, ui2_hash)
+        server_name = wstring(server_name)
+        group_name = wstring(group_name)
+
+        buf = USE_INFO_2.new
+
+        ui2_hash.each do |(k, v)|
+          buf.set(k, v)
+        end
+
+        rc = NetUseAdd(server_name, 2, buf, nil)
+        if rc != NERR_Success
+          Chef::ReservedNames::Win32::Error.raise!(nil, rc)
+        end
+      end
+    end
+    NetUser = Net # For backwards compatibility
+  end
+end