10734377191

Committed 06 Sep 2024 07:34AM UTC coverage: 37.03%. First build

Build # 10734377191

Build Type

push

github

Committed by

lslezak

Commit Message

Adapt files for the SLE-15-SP7 branch

Run Details

748 of 2020 relevant lines covered (37.03%)

3.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.4

/src/include/squid/SquidACL_local_functions.rb

# encoding: utf-8

# ------------------------------------------------------------------------------
# Copyright (c) 2006 Novell, Inc. All Rights Reserved.
#
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of version 2 of the GNU General Public License as published by the
# Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, contact Novell, Inc.
#
# To contact Novell about this file by physical or electronic mail, you may find
# current contact information at www.novell.com.
# ------------------------------------------------------------------------------

# File:        include/squid/SquidACL_local_functions.ycp
# Package:        Configuration of squid
# Summary:        Non-global functions of SquidACL module which are linked with acl_map variable.
# Authors:        Daniel Fiser <dfiser@suse.cz>
#
# $Id$
module Yast
  module SquidSquidACLLocalFunctionsInclude
    def initialize_squid_SquidACL_local_functions(include_target)
      Yast.import "UI"

      textdomain "squid"
      Yast.import "Report"

      Yast.import "Squid"

      Yast.include include_target, "squid/helper_functions.rb"
    end

    def splitToChars(str)
      len = Builtins.size(str)
      i = 0
      ret = []
      while Ops.less_than(i, len)
        ret = Builtins.add(ret, Builtins.substring(str, i, 1))
        i = Ops.add(i, 1)
      end

      deep_copy(ret)
    end

    def isMask(str)
      Builtins.regexpmatch(str, "^[0-9]+$") || isIPAddr(str)
    end

    def isHHMMFormat(str)
      return false if !Builtins.regexpmatch(str, "^[0-9]{1,2}:[0-9]{1,2}$")
      hm = Builtins.splitstring(str, ":")

      tmp = Builtins.tointeger(Ops.get(hm, 0, ""))
      return false if Ops.less_than(tmp, 0) || Ops.greater_than(tmp, 23)
      tmp = Builtins.tointeger(Ops.get(hm, 1, ""))
      return false if Ops.less_than(tmp, 0) || Ops.greater_than(tmp, 59)

      true
    end

    def isCorrectFromTo(from, to)
      fr = Builtins.tointeger(
        Builtins.regexpsub(
          Builtins.mergestring(Builtins.splitstring(from, ":"), ""),
          "([1-9][0-9]*$)",
          "\\1"
        )
      )
      t = Builtins.tointeger(
        Builtins.regexpsub(
          Builtins.mergestring(Builtins.splitstring(to, ":"), ""),
          "([1-9][0-9]*$)",
          "\\1"
        )
      )

      Ops.less_than(fr, t)
    end

    def widgetInitIPAddr(id)
      id = deep_copy(id)
      UI.ChangeWidget(Id(id), :ValidChars, "1234567890.")

      nil
    end

    def widgetInitMask(id)
      id = deep_copy(id)
      UI.ChangeWidget(Id(id), :ValidChars, "1234567890.")

      nil
    end

    def widgetInitDomainName(id)
      id = deep_copy(id)
      UI.ChangeWidget(
        Id(id),
        :ValidChars,
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ."
      )

      nil
    end

    def widgetInitHHMM(id)
      id = deep_copy(id)
      UI.ChangeWidget(Id(id), :ValidChars, "1234567890:")
      UI.ChangeWidget(Id(id), :InputMaxLength, 5)

      nil
    end

    # *****************  SRC  ************************
    def srcWidgetInit(id_item)
      UI.ChangeWidget(Id("acl_addr"), :ValidChars, "1234567890.-")
      widgetInitMask("acl_mask")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        data = Builtins.splitstring(
          Ops.get(Ops.get_list(acl, "options", []), 0, ""),
          "/"
        )

        UI.ChangeWidget(Id("acl_addr"), :Value, Ops.get(data, 0, ""))
        UI.ChangeWidget(Id("acl_mask"), :Value, Ops.get(data, 1, ""))
      end

      nil
    end

    def srcVerif
      ok = true
      addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))
      mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))
      tmp = Builtins.splitstring(addr, "-")

      if Builtins.size(addr) == 0 ||
          !isIPAddr(addr) && !isIPAddr(Ops.get(tmp, 0, "")) &&
              !isIPAddr(Ops.get(tmp, 1, "")) ||
          Ops.greater_than(Builtins.size(mask), 0) && !isMask(mask)
        ok = false
        Report.Error(_("Invalid values."))
      end
      ok
    end

    def srcOptions
      data = []
      addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))
      mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))

      Ops.set(data, 0, addr)
      if Ops.greater_than(Builtins.size(mask), 0) &&
          Ops.greater_than(Builtins.size(addr), 0)
        Ops.set(data, 0, Ops.add(Ops.add(Ops.get(data, 0, ""), "/"), mask))
      end
      deep_copy(data)
    end
    # *****************  SRC END  ********************

    # *****************  DST  ************************
    def dstWidgetInit(id_item)
      widgetInitIPAddr("acl_addr")
      widgetInitMask("acl_mask")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        data = Builtins.splitstring(
          Ops.get(Ops.get_list(acl, "options", []), 0, ""),
          "/"
        )

        UI.ChangeWidget(Id("acl_addr"), :Value, Ops.get(data, 0, ""))
        UI.ChangeWidget(Id("acl_mask"), :Value, Ops.get(data, 1, ""))
      end

      nil
    end

    def dstVerif
      ok = true
      addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))
      mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))

      if !isIPAddr(addr) ||
          Ops.greater_than(Builtins.size(mask), 0) && !isMask(mask)
        ok = false
        Report.Error(_("Invalid values."))
      end
      ok
    end

    def dstOptions
      data = []
      addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))
      mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))

      Ops.set(data, 0, addr)
      if Ops.greater_than(Builtins.size(mask), 0) &&
          Ops.greater_than(Builtins.size(addr), 0)
        Ops.set(data, 0, Ops.add(Ops.add(Ops.get(data, 0, ""), "/"), mask))
      end
      deep_copy(data)
    end
    # *****************  DST END  ********************

    # *****************  MYIP  ************************
    #  * Uses same functions as DST
    # /******************  MYIP END  *******************

    # ***************  SRCDOMAIN  ********************
    def srcdomainWidgetInit(id_item)
      widgetInitDomainName("acl_domain")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        UI.ChangeWidget(
          Id("acl_domain"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def srcdomainVerif
      ok = true

      if Builtins.size(
        Convert.to_string(UI.QueryWidget(Id("acl_domain"), :Value))
      ) == 0
        ok = false
        Report.Error(_("Domain Name must not be empty."))
      end
      ok
    end

    def srcdomainOptions
      [Convert.to_string(UI.QueryWidget(Id("acl_domain"), :Value))]
    end
    # ***************  SRCDOMAIN END  ****************

    # ***************  DSTDOMAIN  *********************
    #  * Uses same functions as SRCDOMAIN.
    # /****************  DSTDOMAIN END  ****************

    # ***************  REGEXP  ***********************
    # Returns universal widget for setting a regular expression.
    def regexpWidget(frame_title)
      Frame(
        frame_title,
        VBox(
          TextEntry(Id("acl_regexp"), _("Regular Expression"), ""),
          Left(
            CheckBox(
              Id("acl_regexp_case_insensitive"),
              _("Case Insensitive"),
              false
            )
          )
        )
      )
    end

    # Universal widget_init for regular expression.
    def regexpWidgetInit(id_item)
      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        if Ops.get(Ops.get_list(acl, "options", []), 0, "") == "-i"
          UI.ChangeWidget(Id("acl_regexp_case_insensitive"), :Value, true)
          Ops.set(
            acl,
            "options",
            Builtins.remove(Ops.get_list(acl, "options", []), 0)
          )
        end
        UI.ChangeWidget(
          Id("acl_regexp"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    # Universal verification function for regular expression.
    def regexpVerif
      ok = true
      regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))

      if Builtins.size(regexp) == 0
        ok = false
        Report.Error(_("Regular Expression must not be empty."))
      end
      ok
    end

    # Universal options function for regular expression.
    def regexpOptions
      ret = []
      if Convert.to_boolean(
        UI.QueryWidget(Id("acl_regexp_case_insensitive"), :Value)
      )
        Ops.set(ret, 0, "-i")
      end
      ret = Builtins.add(
        ret,
        Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))
      )
      deep_copy(ret)
    end

    # Returns map describing acl which has type of regular expression.
    def regexp(name, frame_title, help)
      {
        "name"         => name,
        "widget"       => regexpWidget(frame_title),
        "widget_init"  => fun_ref(method(:regexpWidgetInit), "void (integer)"),
        "verification" => fun_ref(method(:regexpVerif), "boolean ()"),
        "options"      => fun_ref(method(:regexpOptions), "list <string> ()"),
        "help"         => help
      }
    end
    # ***************  REGEXP END  *******************

    # ***************  TIME  *************************
    def timeWidgetInit(id_item)
      widgetInitHHMM("acl_from")
      widgetInitHHMM("acl_to")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        days = splitToChars(Ops.get(Ops.get_list(acl, "options", []), 0, ""))
        times = Builtins.splitstring(
          Ops.get(Ops.get_list(acl, "options", []), 1, ""),
          "-"
        )

        UI.ChangeWidget(Id("acl_days"), :SelectedItems, days)
        UI.ChangeWidget(Id("acl_from"), :Value, Ops.get(times, 0, ""))
        UI.ChangeWidget(Id("acl_to"), :Value, Ops.get(times, 1, ""))
      end

      nil
    end

    def timeVerif
      ok = true
      from = Convert.to_string(UI.QueryWidget(Id("acl_from"), :Value))
      to = Convert.to_string(UI.QueryWidget(Id("acl_to"), :Value))
      selected_items = Builtins.size(
        Convert.to_list(UI.QueryWidget(Id("acl_days"), :SelectedItems))
      )

      if selected_items == 0
        ok = false
        Report.Error(_("You must select at least one day."))
      elsif !isHHMMFormat(from) || !isHHMMFormat(to)
        ok = false
        Report.Error(_("Time is not set in correct format."))
      elsif !isCorrectFromTo(from, to)
        ok = false
        Report.Error(_("From must be less than To.")) # TODO: better error message
      end
      ok
    end

    def timeOptions
      days = Builtins.mergestring(
        Convert.convert(
          UI.QueryWidget(Id("acl_days"), :SelectedItems),
          from: "any",
          to:   "list <string>"
        ),
        ""
      )
      times = Builtins.mergestring(
        [
          Convert.to_string(UI.QueryWidget(Id("acl_from"), :Value)),
          Convert.to_string(UI.QueryWidget(Id("acl_to"), :Value))
        ],
        "-"
      )
      [days, times]
    end
    # ***************  TIME END  *********************

    # ***************  PORT  *************************
    def portWidgetInit(id_item)
      UI.ChangeWidget(Id("acl_port"), :ValidChars, "1234567890-")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        UI.ChangeWidget(
          Id("acl_port"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def portVerif
      ok = true
      port = Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))

      if !Builtins.regexpmatch(port, "^[0-9]+(-[0-9]+){0,1}$")
        ok = false
      else
        ports = Builtins.splitstring(port, "-")
        if Builtins.size(ports) == 2 &&
            Ops.greater_than(
              Builtins.tointeger(Ops.get(ports, 0, "")),
              Builtins.tointeger(Ops.get(ports, 1, ""))
            )
          ok = false
        end
      end
      Report.Error(_("Invalid value.")) if !ok
      ok
    end

    def portOptions
      [Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))]
    end
    # ***************  PORT END  *********************

    # *************  MYPORT  *************************
    def myportWidgetInit(id_item)
      UI.ChangeWidget(Id("acl_port"), :ValidChars, "1234567890")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        UI.ChangeWidget(
          Id("acl_port"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def myportVerif
      ok = true
      port = Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))

      if !Builtins.regexpmatch(port, "^[0-9]+$")
        ok = false
        Report.Error(_("Invalid value."))
      end
      ok
    end
    # *************  MYPORT END  *********************

    # **************  PROTO  *************************
    def protoWidgetInit(id_item)
      UI.ChangeWidget(
        Id("acl_proto"),
        :ValidChars,
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
      )

      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        UI.ChangeWidget(
          Id("acl_proto"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def protoVerif
      ok = true
      protocol = Convert.to_string(UI.QueryWidget(Id("acl_proto"), :Value))

      if Builtins.size(protocol) == 0
        Report.Error(_("Protocol must not be empty."))
      end
      ok
    end

    def protoOptions
      [Convert.to_string(UI.QueryWidget(Id("acl_proto"), :Value))]
    end
    # **************  PROTO END  *********************

    # **************  METHOD  ************************
    def methodWidgetInit(id_item)
      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        UI.ChangeWidget(
          Id("acl_method"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def methodVerif
      true
    end

    def methodOptions
      [Convert.to_string(UI.QueryWidget(Id("acl_method"), :Value))]
    end
    # **************  METHOD END  ********************

    # **************  MAXCONN  ***********************
    def maxconnWidgetInit(id_item)
      if !id_item.nil?
        acl = Squid.GetACL(id_item)

        UI.ChangeWidget(
          Id("acl_connections"),
          :Value,
          Builtins.tointeger(Ops.get(Ops.get_list(acl, "options", []), 0, ""))
        )
      end

      nil
    end

    def maxconnVerif
      true
    end

    def maxconnOptions
      [Builtins.tostring(UI.QueryWidget(Id("acl_connections"), :Value))]
    end
    # **************  MAXCONN END  *******************

    # **************  HEADER  ************************
    def headerWidgetInit(id_item)
      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        UI.ChangeWidget(
          Id("acl_header_name"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
        if Ops.get(Ops.get_list(acl, "options", []), 1, "") == "-i"
          UI.ChangeWidget(
            Id("acl_regexp"),
            :Value,
            Ops.get(Ops.get_list(acl, "options", []), 2, "")
          )
          UI.ChangeWidget(Id("acl_regexp_case_insensitive"), :Value, true)
        else
          UI.ChangeWidget(
            Id("acl_regexp"),
            :Value,
            Ops.get(Ops.get_list(acl, "options", []), 1, "")
          )
        end
      end

      nil
    end

    def headerVerif
      ok = true
      header_name = Convert.to_string(
        UI.QueryWidget(Id("acl_header_name"), :Value)
      )
      regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))

      if Builtins.size(header_name) == 0 && Builtins.size(regexp) == 0
        ok = false
        Report.Error(_("Header Name and Regular Expression must not be empty."))
      end
      ok
    end

    def headerOptions
      header_name = Convert.to_string(
        UI.QueryWidget(Id("acl_header_name"), :Value)
      )
      regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))
      ci = Convert.to_boolean(
        UI.QueryWidget(Id("acl_regexp_case_insensitive"), :Value)
      )
      ret = [header_name]

      ret = Builtins.add(ret, "-i") if ci == true
      ret = Builtins.add(ret, regexp)

      deep_copy(ret)
    end
    # **************  HEADER END  ********************

    # **************  ARP  ***************************
    def arpWidgetInit(id_item)
      UI.ChangeWidget(Id("acl_mac"), :ValidChars, "1234567890ABCDEFabcdef:")

      if !id_item.nil?
        acl = Squid.GetACL(id_item)
        UI.ChangeWidget(
          Id("acl_mac"),
          :Value,
          Ops.get(Ops.get_list(acl, "options", []), 0, "")
        )
      end

      nil
    end

    def arpVerif
      ok = true
      mac = Convert.to_string(UI.QueryWidget(Id("acl_mac"), :Value))
      if Builtins.size(mac) == 0
        ok = false
        # error report
        Report.Error(_("MAC Address must not be empty."))
      elsif !Builtins.regexpmatch(mac, "^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$")
        ok = false
        # error report
        Report.Error(_("Incorrect format of MAC Address."))
      end
      ok
    end

    def arpOptions
      [Convert.to_string(UI.QueryWidget(Id("acl_mac"), :Value))]
    end
  end
end

1	# encoding: utf-8
2
3	# ------------------------------------------------------------------------------
4	# Copyright (c) 2006 Novell, Inc. All Rights Reserved.
5	#
6	#
7	# This program is free software; you can redistribute it and/or modify it under
8	# the terms of version 2 of the GNU General Public License as published by the
9	# Free Software Foundation.
10	#
11	# This program is distributed in the hope that it will be useful, but WITHOUT
12	# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13	# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14	#
15	# You should have received a copy of the GNU General Public License along with
16	# this program; if not, contact Novell, Inc.
17	#
18	# To contact Novell about this file by physical or electronic mail, you may find
19	# current contact information at www.novell.com.
20	# ------------------------------------------------------------------------------
21
22	# File: include/squid/SquidACL_local_functions.ycp
23	# Package: Configuration of squid
24	# Summary: Non-global functions of SquidACL module which are linked with acl_map variable.
25	# Authors: Daniel Fiser <dfiser@suse.cz>
26	#
27	# $Id$
28	module Yast	1✔
29	module SquidSquidACLLocalFunctionsInclude	1✔
30	def initialize_squid_SquidACL_local_functions(include_target)	1✔
31	Yast.import "UI"	1✔
32
33	textdomain "squid"	1✔
34	Yast.import "Report"	1✔
35
36	Yast.import "Squid"	1✔
37
38	Yast.include include_target, "squid/helper_functions.rb"	1✔
39	end
40
41	def splitToChars(str)	1✔
42	len = Builtins.size(str)	×
43	i = 0	×
44	ret = []	×
45	while Ops.less_than(i, len)	×
46	ret = Builtins.add(ret, Builtins.substring(str, i, 1))	×
47	i = Ops.add(i, 1)	×
48	end
49
50	deep_copy(ret)	×
51	end
52
53	def isMask(str)	1✔
54	Builtins.regexpmatch(str, "^[0-9]+$") \|\| isIPAddr(str)	×
55	end
56
57	def isHHMMFormat(str)	1✔
58	return false if !Builtins.regexpmatch(str, "^[0-9]{1,2}:[0-9]{1,2}$")	×
59	hm = Builtins.splitstring(str, ":")	×
60
61	tmp = Builtins.tointeger(Ops.get(hm, 0, ""))	×
62	return false if Ops.less_than(tmp, 0) \|\| Ops.greater_than(tmp, 23)	×
63	tmp = Builtins.tointeger(Ops.get(hm, 1, ""))	×
64	return false if Ops.less_than(tmp, 0) \|\| Ops.greater_than(tmp, 59)	×
65
66	true	×
67	end
68
69	def isCorrectFromTo(from, to)	1✔
70	fr = Builtins.tointeger(	×
71	Builtins.regexpsub(
72	Builtins.mergestring(Builtins.splitstring(from, ":"), ""),
73	"([1-9][0-9]*$)",
74	"\\1"
75	)
76	)
77	t = Builtins.tointeger(	×
78	Builtins.regexpsub(
79	Builtins.mergestring(Builtins.splitstring(to, ":"), ""),
80	"([1-9][0-9]*$)",
81	"\\1"
82	)
83	)
84
85	Ops.less_than(fr, t)	×
86	end
87
88	def widgetInitIPAddr(id)	1✔
89	id = deep_copy(id)	×
90	UI.ChangeWidget(Id(id), :ValidChars, "1234567890.")	×
91
92	nil
93	end
94
95	def widgetInitMask(id)	1✔
96	id = deep_copy(id)	×
97	UI.ChangeWidget(Id(id), :ValidChars, "1234567890.")	×
98
99	nil
100	end
101
102	def widgetInitDomainName(id)	1✔
103	id = deep_copy(id)	×
104	UI.ChangeWidget(	×
105	Id(id),
106	:ValidChars,
107	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ."
108	)
109
110	nil
111	end
112
113	def widgetInitHHMM(id)	1✔
114	id = deep_copy(id)	×
115	UI.ChangeWidget(Id(id), :ValidChars, "1234567890:")	×
116	UI.ChangeWidget(Id(id), :InputMaxLength, 5)	×
117
118	nil
119	end
120
121	# *************** SRC **********************
122	def srcWidgetInit(id_item)	1✔
123	UI.ChangeWidget(Id("acl_addr"), :ValidChars, "1234567890.-")	×
124	widgetInitMask("acl_mask")	×
125
126	if !id_item.nil?	×
127	acl = Squid.GetACL(id_item)	×
128	data = Builtins.splitstring(	×
129	Ops.get(Ops.get_list(acl, "options", []), 0, ""),
130	"/"
131	)
132
133	UI.ChangeWidget(Id("acl_addr"), :Value, Ops.get(data, 0, ""))	×
134	UI.ChangeWidget(Id("acl_mask"), :Value, Ops.get(data, 1, ""))	×
135	end
136
137	nil
138	end
139
140	def srcVerif	1✔
141	ok = true	×
142	addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))	×
143	mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))	×
144	tmp = Builtins.splitstring(addr, "-")	×
145
146	if Builtins.size(addr) == 0 \|\|	×
147	!isIPAddr(addr) && !isIPAddr(Ops.get(tmp, 0, "")) &&
148	!isIPAddr(Ops.get(tmp, 1, "")) \|\|
149	Ops.greater_than(Builtins.size(mask), 0) && !isMask(mask)
150	ok = false	×
151	Report.Error(_("Invalid values."))	×
152	end
153	ok	×
154	end
155
156	def srcOptions	1✔
157	data = []	×
158	addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))	×
159	mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))	×
160
161	Ops.set(data, 0, addr)	×
162	if Ops.greater_than(Builtins.size(mask), 0) &&	×
163	Ops.greater_than(Builtins.size(addr), 0)
164	Ops.set(data, 0, Ops.add(Ops.add(Ops.get(data, 0, ""), "/"), mask))	×
165	end
166	deep_copy(data)	×
167	end
168	# *************** SRC END ******************
169
170	# *************** DST **********************
171	def dstWidgetInit(id_item)	1✔
172	widgetInitIPAddr("acl_addr")	×
173	widgetInitMask("acl_mask")	×
174
175	if !id_item.nil?	×
176	acl = Squid.GetACL(id_item)	×
177	data = Builtins.splitstring(	×
178	Ops.get(Ops.get_list(acl, "options", []), 0, ""),
179	"/"
180	)
181
182	UI.ChangeWidget(Id("acl_addr"), :Value, Ops.get(data, 0, ""))	×
183	UI.ChangeWidget(Id("acl_mask"), :Value, Ops.get(data, 1, ""))	×
184	end
185
186	nil
187	end
188
189	def dstVerif	1✔
190	ok = true	×
191	addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))	×
192	mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))	×
193
194	if !isIPAddr(addr) \|\|	×
195	Ops.greater_than(Builtins.size(mask), 0) && !isMask(mask)
196	ok = false	×
197	Report.Error(_("Invalid values."))	×
198	end
199	ok	×
200	end
201
202	def dstOptions	1✔
203	data = []	×
204	addr = Convert.to_string(UI.QueryWidget(Id("acl_addr"), :Value))	×
205	mask = Convert.to_string(UI.QueryWidget(Id("acl_mask"), :Value))	×
206
207	Ops.set(data, 0, addr)	×
208	if Ops.greater_than(Builtins.size(mask), 0) &&	×
209	Ops.greater_than(Builtins.size(addr), 0)
210	Ops.set(data, 0, Ops.add(Ops.add(Ops.get(data, 0, ""), "/"), mask))	×
211	end
212	deep_copy(data)	×
213	end
214	# *************** DST END ******************
215
216	# *************** MYIP **********************
217	# * Uses same functions as DST
218	# /**************** MYIP END *****************
219
220	# ************* SRCDOMAIN ******************
221	def srcdomainWidgetInit(id_item)	1✔
222	widgetInitDomainName("acl_domain")	×
223
224	if !id_item.nil?	×
225	acl = Squid.GetACL(id_item)	×
226	UI.ChangeWidget(	×
227	Id("acl_domain"),
228	:Value,
229	Ops.get(Ops.get_list(acl, "options", []), 0, "")
230	)
231	end
232
233	nil
234	end
235
236	def srcdomainVerif	1✔
237	ok = true	×
238
239	if Builtins.size(
240	Convert.to_string(UI.QueryWidget(Id("acl_domain"), :Value))
241	) == 0	×
242	ok = false	×
243	Report.Error(_("Domain Name must not be empty."))	×
244	end
245	ok	×
246	end
247
248	def srcdomainOptions	1✔
249	[Convert.to_string(UI.QueryWidget(Id("acl_domain"), :Value))]	×
250	end
251	# ************* SRCDOMAIN END **************
252
253	# ************* DSTDOMAIN *******************
254	# * Uses same functions as SRCDOMAIN.
255	# /************** DSTDOMAIN END **************
256
257	# ************* REGEXP *********************
258	# Returns universal widget for setting a regular expression.
259	def regexpWidget(frame_title)	1✔
260	Frame(	8✔
261	frame_title,
262	VBox(
263	TextEntry(Id("acl_regexp"), _("Regular Expression"), ""),
264	Left(
265	CheckBox(
266	Id("acl_regexp_case_insensitive"),
267	_("Case Insensitive"),
268	false
269	)
270	)
271	)
272	)
273	end
274
275	# Universal widget_init for regular expression.
276	def regexpWidgetInit(id_item)	1✔
277	if !id_item.nil?	×
278	acl = Squid.GetACL(id_item)	×
279
280	if Ops.get(Ops.get_list(acl, "options", []), 0, "") == "-i"	×
281	UI.ChangeWidget(Id("acl_regexp_case_insensitive"), :Value, true)	×
282	Ops.set(	×
283	acl,
284	"options",
285	Builtins.remove(Ops.get_list(acl, "options", []), 0)
286	)
287	end
288	UI.ChangeWidget(	×
289	Id("acl_regexp"),
290	:Value,
291	Ops.get(Ops.get_list(acl, "options", []), 0, "")
292	)
293	end
294
295	nil
296	end
297
298	# Universal verification function for regular expression.
299	def regexpVerif	1✔
300	ok = true	×
301	regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))	×
302
303	if Builtins.size(regexp) == 0	×
304	ok = false	×
305	Report.Error(_("Regular Expression must not be empty."))	×
306	end
307	ok	×
308	end
309
310	# Universal options function for regular expression.
311	def regexpOptions	1✔
312	ret = []	×
313	if Convert.to_boolean(	×
314	UI.QueryWidget(Id("acl_regexp_case_insensitive"), :Value)
315	)
316	Ops.set(ret, 0, "-i")	×
317	end
318	ret = Builtins.add(	×
319	ret,
320	Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))
321	)
322	deep_copy(ret)	×
323	end
324
325	# Returns map describing acl which has type of regular expression.
326	def regexp(name, frame_title, help)	1✔
327	{	8✔
328	"name" => name,
329	"widget" => regexpWidget(frame_title),
330	"widget_init" => fun_ref(method(:regexpWidgetInit), "void (integer)"),
331	"verification" => fun_ref(method(:regexpVerif), "boolean ()"),
332	"options" => fun_ref(method(:regexpOptions), "list <string> ()"),
333	"help" => help
334	}
335	end
336	# ************* REGEXP END *****************
337
338	# ************* TIME ***********************
339	def timeWidgetInit(id_item)	1✔
340	widgetInitHHMM("acl_from")	×
341	widgetInitHHMM("acl_to")	×
342
343	if !id_item.nil?	×
344	acl = Squid.GetACL(id_item)	×
345	days = splitToChars(Ops.get(Ops.get_list(acl, "options", []), 0, ""))	×
346	times = Builtins.splitstring(	×
347	Ops.get(Ops.get_list(acl, "options", []), 1, ""),
348	"-"
349	)
350
351	UI.ChangeWidget(Id("acl_days"), :SelectedItems, days)	×
352	UI.ChangeWidget(Id("acl_from"), :Value, Ops.get(times, 0, ""))	×
353	UI.ChangeWidget(Id("acl_to"), :Value, Ops.get(times, 1, ""))	×
354	end
355
356	nil
357	end
358
359	def timeVerif	1✔
360	ok = true	×
361	from = Convert.to_string(UI.QueryWidget(Id("acl_from"), :Value))	×
362	to = Convert.to_string(UI.QueryWidget(Id("acl_to"), :Value))	×
363	selected_items = Builtins.size(	×
364	Convert.to_list(UI.QueryWidget(Id("acl_days"), :SelectedItems))
365	)
366
367	if selected_items == 0	×
368	ok = false	×
369	Report.Error(_("You must select at least one day."))	×
370	elsif !isHHMMFormat(from) \|\| !isHHMMFormat(to)	×
371	ok = false	×
372	Report.Error(_("Time is not set in correct format."))	×
373	elsif !isCorrectFromTo(from, to)	×
374	ok = false	×
375	Report.Error(_("From must be less than To.")) # TODO: better error message	×
376	end
377	ok	×
378	end
379
380	def timeOptions	1✔
381	days = Builtins.mergestring(	×
382	Convert.convert(
383	UI.QueryWidget(Id("acl_days"), :SelectedItems),
384	from: "any",
385	to: "list <string>"
386	),
387	""
388	)
389	times = Builtins.mergestring(	×
390	[
391	Convert.to_string(UI.QueryWidget(Id("acl_from"), :Value)),
392	Convert.to_string(UI.QueryWidget(Id("acl_to"), :Value))
393	],
394	"-"
395	)
396	[days, times]	×
397	end
398	# ************* TIME END *******************
399
400	# ************* PORT ***********************
401	def portWidgetInit(id_item)	1✔
402	UI.ChangeWidget(Id("acl_port"), :ValidChars, "1234567890-")	×
403
404	if !id_item.nil?	×
405	acl = Squid.GetACL(id_item)	×
406
407	UI.ChangeWidget(	×
408	Id("acl_port"),
409	:Value,
410	Ops.get(Ops.get_list(acl, "options", []), 0, "")
411	)
412	end
413
414	nil
415	end
416
417	def portVerif	1✔
418	ok = true	×
419	port = Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))	×
420
421	if !Builtins.regexpmatch(port, "^[0-9]+(-[0-9]+){0,1}$")	×
422	ok = false	×
423	else
424	ports = Builtins.splitstring(port, "-")	×
425	if Builtins.size(ports) == 2 &&	×
426	Ops.greater_than(
427	Builtins.tointeger(Ops.get(ports, 0, "")),
428	Builtins.tointeger(Ops.get(ports, 1, ""))
429	)
430	ok = false	×
431	end
432	end
433	Report.Error(_("Invalid value.")) if !ok	×
434	ok	×
435	end
436
437	def portOptions	1✔
438	[Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))]	×
439	end
440	# ************* PORT END *******************
441
442	# *********** MYPORT ***********************
443	def myportWidgetInit(id_item)	1✔
444	UI.ChangeWidget(Id("acl_port"), :ValidChars, "1234567890")	×
445
446	if !id_item.nil?	×
447	acl = Squid.GetACL(id_item)	×
448
449	UI.ChangeWidget(	×
450	Id("acl_port"),
451	:Value,
452	Ops.get(Ops.get_list(acl, "options", []), 0, "")
453	)
454	end
455
456	nil
457	end
458
459	def myportVerif	1✔
460	ok = true	×
461	port = Convert.to_string(UI.QueryWidget(Id("acl_port"), :Value))	×
462
463	if !Builtins.regexpmatch(port, "^[0-9]+$")	×
464	ok = false	×
465	Report.Error(_("Invalid value."))	×
466	end
467	ok	×
468	end
469	# *********** MYPORT END *******************
470
471	# ************ PROTO ***********************
472	def protoWidgetInit(id_item)	1✔
473	UI.ChangeWidget(	×
474	Id("acl_proto"),
475	:ValidChars,
476	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
477	)
478
479	if !id_item.nil?	×
480	acl = Squid.GetACL(id_item)	×
481
482	UI.ChangeWidget(	×
483	Id("acl_proto"),
484	:Value,
485	Ops.get(Ops.get_list(acl, "options", []), 0, "")
486	)
487	end
488
489	nil
490	end
491
492	def protoVerif	1✔
493	ok = true	×
494	protocol = Convert.to_string(UI.QueryWidget(Id("acl_proto"), :Value))	×
495
496	if Builtins.size(protocol) == 0	×
497	Report.Error(_("Protocol must not be empty."))	×
498	end
499	ok	×
500	end
501
502	def protoOptions	1✔
503	[Convert.to_string(UI.QueryWidget(Id("acl_proto"), :Value))]	×
504	end
505	# ************ PROTO END *******************
506
507	# ************ METHOD **********************
508	def methodWidgetInit(id_item)	1✔
509	if !id_item.nil?	×
510	acl = Squid.GetACL(id_item)	×
511
512	UI.ChangeWidget(	×
513	Id("acl_method"),
514	:Value,
515	Ops.get(Ops.get_list(acl, "options", []), 0, "")
516	)
517	end
518
519	nil
520	end
521
522	def methodVerif	1✔
523	true	×
524	end
525
526	def methodOptions	1✔
527	[Convert.to_string(UI.QueryWidget(Id("acl_method"), :Value))]	×
528	end
529	# ************ METHOD END ******************
530
531	# ************ MAXCONN *********************
532	def maxconnWidgetInit(id_item)	1✔
533	if !id_item.nil?	×
534	acl = Squid.GetACL(id_item)	×
535
536	UI.ChangeWidget(	×
537	Id("acl_connections"),
538	:Value,
539	Builtins.tointeger(Ops.get(Ops.get_list(acl, "options", []), 0, ""))
540	)
541	end
542
543	nil
544	end
545
546	def maxconnVerif	1✔
547	true	×
548	end
549
550	def maxconnOptions	1✔
551	[Builtins.tostring(UI.QueryWidget(Id("acl_connections"), :Value))]	×
552	end
553	# ************ MAXCONN END *****************
554
555	# ************ HEADER **********************
556	def headerWidgetInit(id_item)	1✔
557	if !id_item.nil?	×
558	acl = Squid.GetACL(id_item)	×
559	UI.ChangeWidget(	×
560	Id("acl_header_name"),
561	:Value,
562	Ops.get(Ops.get_list(acl, "options", []), 0, "")
563	)
564	if Ops.get(Ops.get_list(acl, "options", []), 1, "") == "-i"	×
565	UI.ChangeWidget(	×
566	Id("acl_regexp"),
567	:Value,
568	Ops.get(Ops.get_list(acl, "options", []), 2, "")
569	)
570	UI.ChangeWidget(Id("acl_regexp_case_insensitive"), :Value, true)	×
571	else
572	UI.ChangeWidget(	×
573	Id("acl_regexp"),
574	:Value,
575	Ops.get(Ops.get_list(acl, "options", []), 1, "")
576	)
577	end
578	end
579
580	nil
581	end
582
583	def headerVerif	1✔
584	ok = true	×
585	header_name = Convert.to_string(	×
586	UI.QueryWidget(Id("acl_header_name"), :Value)
587	)
588	regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))	×
589
590	if Builtins.size(header_name) == 0 && Builtins.size(regexp) == 0	×
591	ok = false	×
592	Report.Error(_("Header Name and Regular Expression must not be empty."))	×
593	end
594	ok	×
595	end
596
597	def headerOptions	1✔
598	header_name = Convert.to_string(	×
599	UI.QueryWidget(Id("acl_header_name"), :Value)
600	)
601	regexp = Convert.to_string(UI.QueryWidget(Id("acl_regexp"), :Value))	×
602	ci = Convert.to_boolean(	×
603	UI.QueryWidget(Id("acl_regexp_case_insensitive"), :Value)
604	)
605	ret = [header_name]	×
606
607	ret = Builtins.add(ret, "-i") if ci == true	×
608	ret = Builtins.add(ret, regexp)	×
609
610	deep_copy(ret)	×
611	end
612	# ************ HEADER END ******************
613
614	# ************ ARP *************************
615	def arpWidgetInit(id_item)	1✔
616	UI.ChangeWidget(Id("acl_mac"), :ValidChars, "1234567890ABCDEFabcdef:")	×
617
618	if !id_item.nil?	×
619	acl = Squid.GetACL(id_item)	×
620	UI.ChangeWidget(	×
621	Id("acl_mac"),
622	:Value,
623	Ops.get(Ops.get_list(acl, "options", []), 0, "")
624	)
625	end
626
627	nil
628	end
629
630	def arpVerif	1✔
631	ok = true	×
632	mac = Convert.to_string(UI.QueryWidget(Id("acl_mac"), :Value))	×
633	if Builtins.size(mac) == 0	×
634	ok = false	×
635	# error report
636	Report.Error(_("MAC Address must not be empty."))	×
637	elsif !Builtins.regexpmatch(mac, "^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$")	×
638	ok = false	×
639	# error report
640	Report.Error(_("Incorrect format of MAC Address."))	×
641	end
642	ok	×
643	end
644
645	def arpOptions	1✔
646	[Convert.to_string(UI.QueryWidget(Id("acl_mac"), :Value))]	×
647	end
648	end
649	end

yast / yast-squid / 10734377191

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous