openvox 8.19.0

data/lib/puppet/util/symbolic_file_mode.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util'
+
+module Puppet
+module Util
+module SymbolicFileMode
+  SetUIDBit = ReadBit  = 4
+  SetGIDBit = WriteBit = 2
+  StickyBit = ExecBit  = 1
+  SymbolicMode = { 'x' => ExecBit, 'w' => WriteBit, 'r' => ReadBit }
+  SymbolicSpecialToBit = {
+    't' => { 'u' => StickyBit, 'g' => StickyBit, 'o' => StickyBit },
+    's' => { 'u' => SetUIDBit, 'g' => SetGIDBit, 'o' => StickyBit }
+  }
+
+  def valid_symbolic_mode?(value)
+    value = normalize_symbolic_mode(value)
+    return true if value =~ /^0?[0-7]{1,4}$/
+    return true if value =~ /^([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*$/
+
+    false
+  end
+
+  def display_mode(value)
+    if value =~ /^0?[0-7]{1,4}$/
+      value.rjust(4, "0")
+    else
+      value
+    end
+  end
+
+  def normalize_symbolic_mode(value)
+    return nil if value.nil?
+
+    # We need to treat integers as octal numbers.
+    #
+    # "A numeric mode is from one to four octal digits (0-7), derived by adding
+    # up the bits with values 4, 2, and 1. Omitted digits are assumed to be
+    # leading zeros."
+    case value
+    when Numeric
+      value.to_s(8)
+    when /^0?[0-7]{1,4}$/
+      value.to_i(8).to_s(8) # strip leading 0's
+    else
+      value
+    end
+  end
+
+  def symbolic_mode_to_int(modification, to_mode = 0, is_a_directory = false)
+    if modification.nil? or modification == ''
+      raise Puppet::Error, _("An empty mode string is illegal")
+    elsif modification =~ /^[0-7]+$/
+      return modification.to_i(8)
+    elsif modification =~ /^\d+$/
+      raise Puppet::Error, _("Numeric modes must be in octal, not decimal!")
+    end
+
+    fail _("non-numeric current mode (%{mode})") % { mode: to_mode.inspect } unless to_mode.is_a?(Numeric)
+
+    original_mode = {
+      's' => (to_mode & 0o7000) >> 9,
+      'u' => (to_mode & 0o0700) >> 6,
+      'g' => (to_mode & 0o0070) >> 3,
+      'o' => (to_mode & 0o0007) >> 0,
+      # Are there any execute bits set in the original mode?
+      'any x?' => (to_mode & 0o0111) != 0
+    }
+    final_mode = {
+      's' => original_mode['s'],
+      'u' => original_mode['u'],
+      'g' => original_mode['g'],
+      'o' => original_mode['o'],
+    }
+
+    modification.split(/\s*,\s*/).each do |part|
+      _, to, dsl = /^([ugoa]*)([-+=].*)$/.match(part).to_a
+      if dsl.nil? then raise Puppet::Error, _('Missing action') end
+
+      to = "a" unless to and to.length > 0
+
+      # We want a snapshot of the mode before we start messing with it to
+      # make actions like 'a-g' atomic.  Various parts of the DSL refer to
+      # the original mode, the final mode, or the current snapshot of the
+      # mode, for added fun.
+      snapshot_mode = {}
+      final_mode.each { |k, v| snapshot_mode[k] = v }
+
+      to.gsub('a', 'ugo').split('').uniq.each do |who|
+        value = snapshot_mode[who]
+
+        action = '!'
+        actions = {
+          '!' => ->(_, _) { raise Puppet::Error, _('Missing operation (-, =, or +)') },
+          '=' => ->(m, v) { m | v },
+          '+' => ->(m, v) { m | v },
+          '-' => ->(m, v) { m & ~v },
+        }
+
+        dsl.split('').each do |op|
+          case op
+          when /[-+=]/
+            action = op
+            # Clear all bits, if this is assignment
+            value  = 0 if op == '='
+
+          when /[ugo]/
+            value = actions[action].call(value, snapshot_mode[op])
+
+          when /[rwx]/
+            value = actions[action].call(value, SymbolicMode[op])
+
+          when 'X'
+            # Only meaningful in combination with "set" actions.
+            if action != '+'
+              raise Puppet::Error, _("X only works with the '+' operator")
+            end
+
+            # As per the BSD manual page, set if this is a directory, or if
+            # any execute bit is set on the original (unmodified) mode.
+            # Ignored otherwise; it is "add if", not "add or clear".
+            if is_a_directory or original_mode['any x?']
+              value = actions[action].call(value, ExecBit)
+            end
+
+          when /[st]/
+            bit = SymbolicSpecialToBit[op][who] or fail _("internal error")
+            final_mode['s'] = actions[action].call(final_mode['s'], bit)
+
+          else
+            raise Puppet::Error, _('Unknown operation')
+          end
+        end
+
+        # Now, assign back the value.
+        final_mode[who] = value
+      end
+    rescue Puppet::Error => e
+      if part.inspect != modification.inspect
+        rest = " at #{part.inspect}"
+      else
+        rest = ''
+      end
+
+      raise Puppet::Error, _("%{error}%{rest} in symbolic mode %{modification}") % { error: e, rest: rest, modification: modification.inspect }, e.backtrace
+    end
+
+    final_mode['s'] << 9 |
+      final_mode['u'] << 6 |
+      final_mode['g'] << 3 |
+      final_mode['o'] << 0
+  end
+end
+end
+end

data/lib/puppet/util/tag_set.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '../../puppet/network/format_support'
+
+class Puppet::Util::TagSet < Set
+  include Puppet::Network::FormatSupport
+
+  def self.from_yaml(yaml)
+    new(Puppet::Util::Yaml.safe_load(yaml, [Symbol]))
+  end
+
+  def to_yaml
+    @hash.keys.to_yaml
+  end
+
+  def self.from_data_hash(data)
+    new(data)
+  end
+
+  # TODO: A method named #to_data_hash should not return an array
+  def to_data_hash
+    to_a
+  end
+
+  def join(*args)
+    to_a.join(*args)
+  end
+end

data/lib/puppet/util/tagging.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/tag_set'
+
+module Puppet::Util::Tagging
+  ValidTagRegex = /\A[[:alnum:]_][[:alnum:]_:.-]*\Z/u
+
+  # Add a tag to the current tag set.
+  # When a tag set is used for a scope, these tags will be added to all of
+  # the objects contained in this scope when the objects are finished.
+  #
+  def tag(*ary)
+    @tags ||= new_tags
+
+    ary.flatten.compact.each do |tag|
+      name = tag.to_s.downcase
+      # Add the tag before testing if it's valid since this means that
+      # we never need to test the same valid tag twice. This speeds things
+      # up since we get a lot of duplicates and rarely fail on bad tags
+      if @tags.add?(name)
+        # not seen before, so now we test if it is valid
+        if valid_tag?(name)
+          if split_qualified_tags?
+            # avoid adding twice by first testing if the string contains '::'
+            @tags.merge(name.split('::')) if name.include?('::')
+          end
+        else
+          @tags.delete(name)
+          fail(Puppet::ParseError, _("Invalid tag '%{name}'") % { name: name })
+        end
+      end
+    end
+  end
+
+  # Add a name to the current tag set. Silently ignore names that does not
+  # represent valid tags.
+  #
+  # Use this method instead of doing this:
+  #
+  #  tag(name) if is_valid?(name)
+  #
+  # since that results in testing the same string twice
+  #
+  def tag_if_valid(name)
+    if name.is_a?(String) && valid_tag?(name)
+      name = name.downcase
+      @tags ||= new_tags
+      if @tags.add?(name) && name.include?('::')
+        @tags.merge(name.split('::'))
+      end
+    end
+  end
+
+  # Answers if this resource is tagged with at least one of the given tags.
+  #
+  # The given tags are converted to downcased strings before the match is performed.
+  #
+  # @param *tags [String] splat of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def tagged?(*tags)
+    raw_tagged?(tags.collect { |t| t.to_s.downcase })
+  end
+
+  # Answers if this resource is tagged with at least one of the tags given in downcased string form.
+  #
+  # The method is a faster variant of the tagged? method that does no conversion of its
+  # arguments.
+  #
+  # @param tag_array [Array[String]] array of tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def raw_tagged?(tag_array)
+    my_tags = tags
+    !tag_array.index { |t| my_tags.include?(t) }.nil?
+  end
+
+  # Only use this method when copying known tags from one Tagging instance to another
+  def set_tags(tag_source)
+    @tags = tag_source.tags
+  end
+
+  # Return a copy of the tag list, so someone can't ask for our tags
+  # and then modify them.
+  def tags
+    @tags ||= new_tags
+    @tags.dup
+  end
+
+  # Merge tags from a tagged instance with no attempts to split, downcase
+  # or verify the tags
+  def merge_tags_from(tag_source)
+    @tags ||= new_tags
+    tag_source.merge_into(@tags)
+  end
+
+  # Merge the tags of this instance into the provide TagSet
+  def merge_into(tag_set)
+    tag_set.merge(@tags) unless @tags.nil?
+  end
+
+  def tags=(tags)
+    @tags = new_tags
+
+    return if tags.nil?
+
+    tags = tags.strip.split(/\s*,\s*/) if tags.is_a?(String)
+    tag(*tags)
+  end
+
+  def valid_tag?(maybe_tag)
+    tag_enc = maybe_tag.encoding
+    if tag_enc == Encoding::UTF_8 || tag_enc == Encoding::ASCII
+      maybe_tag =~ ValidTagRegex
+    else
+      maybe_tag.encode(Encoding::UTF_8) =~ ValidTagRegex
+    end
+  rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
+    false
+  end
+
+  private
+
+  def split_qualified_tags?
+    true
+  end
+
+  def new_tags
+    Puppet::Util::TagSet.new
+  end
+end

data/lib/puppet/util/terminal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Terminal
+  # Attempts to determine the width of the terminal.  This is currently only
+  # supported on POSIX systems, and relies on the claims of `stty` (or `tput`).
+  #
+  # Inspired by code from Thor; thanks wycats!
+  # @return [Number] The column width of the terminal.  Defaults to 80 columns.
+  def self.width
+    if Puppet.features.posix?
+      result = %x(stty size 2>/dev/null).split[1] ||
+               %x(tput cols 2>/dev/null).split[0]
+    end
+    (result || '80').to_i
+  rescue
+    80
+  end
+end

data/lib/puppet/util/user_attr.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class UserAttr
+  def self.get_attributes_by_name(name)
+    attributes = nil
+
+    File.readlines('/etc/user_attr').each do |line|
+      next if line =~ /^#/
+
+      token = line.split(':')
+
+      next unless token[0] == name
+
+      attributes = { :name => name }
+      token[4].split(';').each do |attr|
+        key_value = attr.split('=')
+        attributes[key_value[0].intern] = key_value[1].strip
+      end
+      break
+    end
+    attributes
+  end
+end

data/lib/puppet/util/warnings.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Methods to help with handling warnings.
+module Puppet::Util::Warnings
+  module_function
+
+  def notice_once(msg)
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.notice msg }
+  end
+
+  def debug_once(msg)
+    return nil unless Puppet[:debug]
+
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.debug msg }
+  end
+
+  def warnonce(msg)
+    Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.warning msg }
+  end
+
+  def clear_warnings
+    @stampwarnings = {}
+    nil
+  end
+
+  def self.maybe_log(message, klass)
+    @stampwarnings ||= {}
+    @stampwarnings[klass] ||= []
+    return nil if @stampwarnings[klass].include? message
+
+    yield
+    @stampwarnings[klass] << message
+    nil
+  end
+end

data/lib/puppet/util/watched_file.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../puppet/util/watcher'
+
+# Monitor a given file for changes on a periodic interval. Changes are detected
+# by looking for a change in the file ctime.
+class Puppet::Util::WatchedFile
+  # @!attribute [r] filename
+  #   @return [String] The fully qualified path to the file.
+  attr_reader :filename
+
+  # @param filename [String] The fully qualified path to the file.
+  # @param timer [Puppet::Util::Watcher::Timer] The polling interval for checking for file
+  #   changes. Setting the timeout to a negative value will treat the file as
+  #   always changed. Defaults to `Puppet[:filetimeout]`
+  def initialize(filename, timer = Puppet::Util::Watcher::Timer.new(Puppet[:filetimeout]))
+    @filename = filename
+    @timer = timer
+
+    @info = Puppet::Util::Watcher::PeriodicWatcher.new(
+      Puppet::Util::Watcher::Common.file_ctime_change_watcher(@filename),
+      timer
+    )
+  end
+
+  # @return [true, false] If the file has changed since it was last checked.
+  def changed?
+    @info.changed?
+  end
+
+  # Allow this to be used as the name of the file being watched in various
+  # other methods (such as Puppet::FileSystem.exist?)
+  def to_str
+    @filename
+  end
+
+  def to_s
+    "<WatchedFile: filename = #{@filename}, timeout = #{@timer.timeout}>"
+  end
+end

data/lib/puppet/util/watcher/change_watcher.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Watches for changes over time. It only re-examines the values when it is requested to update readings.
+# @api private
+class Puppet::Util::Watcher::ChangeWatcher
+  def self.watch(reader)
+    Puppet::Util::Watcher::ChangeWatcher.new(nil, nil, reader).next_reading
+  end
+
+  def initialize(previous, current, value_reader)
+    @previous = previous
+    @current = current
+    @value_reader = value_reader
+  end
+
+  def changed?
+    if uncertain?
+      false
+    else
+      @previous != @current
+    end
+  end
+
+  def uncertain?
+    @previous.nil? || @current.nil?
+  end
+
+  def change_current_reading_to(new_value)
+    Puppet::Util::Watcher::ChangeWatcher.new(@current, new_value, @value_reader)
+  end
+
+  def next_reading
+    change_current_reading_to(@value_reader.call)
+  end
+end

data/lib/puppet/util/watcher/periodic_watcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Monitor a given watcher for changes on a periodic interval.
+class Puppet::Util::Watcher::PeriodicWatcher
+  # @param watcher [Puppet::Util::Watcher::ChangeWatcher] a watcher for the value to watch
+  # @param timer [Puppet::Util::Watcher::Timer] A timer to determine when to
+  #   recheck the watcher. If the timeout of the timer is negative, then the
+  #   watched value is always considered to be changed
+  def initialize(watcher, timer)
+    @watcher = watcher
+    @timer = timer
+
+    @timer.start
+  end
+
+  # @return [true, false] If the file has changed since it was last checked.
+  def changed?
+    return true if always_consider_changed?
+
+    @watcher = examine_watched_info(@watcher)
+    @watcher.changed?
+  end
+
+  private
+
+  def always_consider_changed?
+    @timer.timeout < 0
+  end
+
+  def examine_watched_info(known)
+    if @timer.expired?
+      @timer.start
+      known.next_reading
+    else
+      known
+    end
+  end
+end

data/lib/puppet/util/watcher/timer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Puppet::Util::Watcher::Timer
+  attr_reader :timeout
+
+  def initialize(timeout)
+    @timeout = timeout
+  end
+
+  def start
+    @start_time = now
+  end
+
+  def expired?
+    (now - @start_time) >= @timeout
+  end
+
+  def now
+    Time.now.to_i
+  end
+end

data/lib/puppet/util/watcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Puppet::Util::Watcher
+  require_relative 'watcher/timer'
+  require_relative 'watcher/change_watcher'
+  require_relative 'watcher/periodic_watcher'
+
+  module Common
+    def self.file_ctime_change_watcher(filename)
+      Puppet::Util::Watcher::ChangeWatcher.watch(lambda do
+        Puppet::FileSystem.stat(filename).ctime
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        :absent
+      end)
+    end
+  end
+end

data/lib/puppet/util/windows/access_control_entry.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Windows Access Control Entry
+#
+# Represents an access control entry, which grants or denies a subject,
+# identified by a SID, rights to a securable object.
+#
+# @see https://msdn.microsoft.com/en-us/library/windows/desktop/aa374868(v=vs.85).aspx
+# @api private
+class Puppet::Util::Windows::AccessControlEntry
+  require_relative '../../../puppet/util/windows/security'
+  include Puppet::Util::Windows::SID
+
+  attr_accessor :sid
+  attr_reader :mask, :flags, :type
+
+  OBJECT_INHERIT_ACE                      = 0x1
+  CONTAINER_INHERIT_ACE                   = 0x2
+  NO_PROPAGATE_INHERIT_ACE                = 0x4
+  INHERIT_ONLY_ACE                        = 0x8
+  INHERITED_ACE                           = 0x10
+
+  ACCESS_ALLOWED_ACE_TYPE                 = 0x0
+  ACCESS_DENIED_ACE_TYPE                  = 0x1
+
+  def initialize(sid, mask, flags = 0, type = ACCESS_ALLOWED_ACE_TYPE)
+    @sid = sid
+    @mask = mask
+    @flags = flags
+    @type = type
+  end
+
+  # Returns true if this ACE is inherited from a parent. If false,
+  # then the ACE is set directly on the object to which it refers.
+  #
+  # @return [Boolean] true if the ACE is inherited
+  def inherited?
+    (@flags & INHERITED_ACE) == INHERITED_ACE
+  end
+
+  # Returns true if this ACE only applies to children of the object.
+  # If false, it applies to the object.
+  #
+  # @return [Boolean] true if the ACE only applies to children and
+  # not the object itself.
+  def inherit_only?
+    (@flags & INHERIT_ONLY_ACE) == INHERIT_ONLY_ACE
+  end
+
+  # Returns true if this ACE applies to child directories.
+  #
+  # @return [Boolean] true if the ACE applies to child directories
+  def container_inherit?
+    (@flags & CONTAINER_INHERIT_ACE) == CONTAINER_INHERIT_ACE
+  end
+
+  # Returns true if this ACE applies to child files.
+  #
+  # @return [Boolean] true if the ACE applies to child files.
+  def object_inherit?
+    (@flags & OBJECT_INHERIT_ACE) == OBJECT_INHERIT_ACE
+  end
+
+  def inspect
+    inheritance = ''.dup
+    inheritance << '(I)' if inherited?
+    inheritance << '(OI)' if object_inherit?
+    inheritance << '(CI)' if container_inherit?
+    inheritance << '(IO)' if inherit_only?
+
+    left = "#{sid_to_name(sid)}:#{inheritance}"
+    left = left.ljust(45)
+    "#{left} 0x#{mask.to_s(16)}"
+  end
+
+  # Returns true if this ACE is equal to +other+
+  def ==(other)
+    self.class == other.class &&
+      sid == other.sid &&
+      mask == other.mask &&
+      flags == other.flags &&
+      type == other.type
+  end
+
+  alias eql? ==
+end