home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / modules / SuSEFirewallProposal.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  16.1 KB  |  476 lines
  1. /**
  2.  * File:    modules/SuSEFirewallProposal.ycp
  3.  * Package:    SuSEFirewall configuration
  4.  * Summary:    Functional interface for SuSEFirewall installation proposal
  5.  * Authors:    Lukas Ocilka <locilka@suse.cz>
  6.  *
  7.  * $Id: SuSEFirewallProposal.ycp 33164 2006-09-27 08:42:24Z jsrain $
  8.  *
  9.  * This module provides a functional API for Installation proposal of SuSEfirewall2
  10.  */
  11.  
  12. {
  13.     module "SuSEFirewallProposal";
  14.     textdomain "base";
  15.  
  16.     import "SuSEFirewall";
  17.     import "ProductFeatures";
  18.     import "Linuxrc";
  19.     import "Package";
  20.  
  21.     # <!-- SuSEFirewall LOCAL VARIABLES //-->
  22.  
  23.     /* proposal was changed by user */
  24.     boolean proposal_changed_by_user = false;
  25.  
  26.     /* proposal was initialized yet */
  27.     boolean proposal_initialized = false;
  28.  
  29.     /* known interfaces */
  30.     list <string> known_interfaces = [];
  31.  
  32.     /* warnings for this "turn" */
  33.     list <string> warnings_now = [];
  34.     
  35.     # <!-- SuSEFirewall LOCAL VARIABLES //-->
  36.  
  37.     # <!-- SuSEFirewall LOCAL FUNCTIONS //-->
  38.  
  39.     /**
  40.      * Local function adds another warning string into warnings for user
  41.      *
  42.      * @param    string warning
  43.      */
  44.     void AddWarning (string warning) {
  45.     warnings_now = add (warnings_now, warning);
  46.     }
  47.  
  48.     /**
  49.      * Local function clears all warnings for user from memory
  50.      */
  51.     void ClearWarnings () {
  52.     warnings_now = [];
  53.     }
  54.  
  55.     /**
  56.      * Function returns list of warnings for user
  57.      *
  58.      * @return    list [string] of warnings
  59.      */
  60.     list <string> GetWarnings () {
  61.     return warnings_now;
  62.     }
  63.  
  64.     /**
  65.      * Local function sets currently known interfaces.
  66.      *
  67.      * @param    list [string] of known interfaces
  68.      */
  69.     void SetKnownInterfaces(list <string> interfaces) {
  70.     known_interfaces = interfaces;
  71.     }
  72.  
  73.     /**
  74.      * Local function returns list [string] of known interfaces.
  75.      * They must have been set using SetKnownInterfaces(list [string] interfaces)
  76.      * function.
  77.      *
  78.      * @return    list <string> of known interfaces
  79.      */
  80.     list <string> GetKnownInterfaces () {
  81.     return known_interfaces;
  82.     }
  83.  
  84.     /**
  85.      * Function returns if interface is a dial-up type.
  86.      *
  87.      * @return    boolean if is dial-up interface
  88.      */
  89.     boolean IsDialUpInterface (string interface) {
  90.     list <map <string, string> > all_interfaces = SuSEFirewall::GetAllKnownInterfaces();
  91.  
  92.     string interface_type = nil;
  93.     foreach (map <string, string> one, all_interfaces, {
  94.         if (one["id"]:nil != interface) return;
  95.         // this is THE interface
  96.         interface_type = one["type"]:nil;
  97.     });
  98.  
  99.     return (interface_type == "dialup");
  100.     }
  101.  
  102.     /**
  103.      * Local function adds list of interfaces into zone.
  104.      *
  105.      * @param    list [string] of interfaces
  106.      * @param    string zone
  107.      */
  108.     void SetInterfacesToZone(list <string> interfaces, string zone) {
  109.     foreach (string interface, interfaces, {
  110.         SuSEFirewall::AddInterfaceIntoZone(interface, zone);
  111.     });
  112.     }
  113.  
  114.     /**
  115.      * Local function for updating user-changed proposal.
  116.      */
  117.     void UpdateProposal () {
  118.     list <string> last_known_interfaces = GetKnownInterfaces();
  119.     list <string> currently_known_interfaces = SuSEFirewall::GetListOfKnownInterfaces();
  120.  
  121.     boolean had_dialup_interfaces = false;
  122.     foreach (string this_interface, last_known_interfaces, {
  123.         if (IsDialUpInterface(this_interface)) {
  124.         had_dialup_interfaces = true;
  125.         break;
  126.         }
  127.     });
  128.  
  129.     foreach (string interface, currently_known_interfaces, {
  130.         // already configured
  131.         if (contains(last_known_interfaces, interface)) return;
  132.  
  133.         // any dial-up interfaces presented and the new one isn't dial-up
  134.         if (had_dialup_interfaces && ! IsDialUpInterface(interface)) {
  135.         AddWarning( sformat(
  136.             // TRANSLATORS: Warning in installation proposal, %1 is a device name (eth0, sl0, ...)
  137.             _("New network device '%1' found; added as an internal firewall interface"),
  138.             interface)
  139.         );
  140.         SetInterfacesToZone([interface], "INT");
  141.         } else {
  142.         AddWarning( sformat(
  143.             // TRANSLATORS: Warning in installation proposal, %1 is a device name (eth0, sl0, ...)
  144.             _("New network device '%1' found; added as an external firewall interface"),
  145.             interface)
  146.         );
  147.         SetInterfacesToZone([interface], "EXT");
  148.         }
  149.     });
  150.  
  151.     SetKnownInterfaces(currently_known_interfaces);
  152.     }
  153.  
  154.     /**
  155.      * Function opens up the service on all non-dial-up network interfaces.
  156.      * If there are no network interfaces known and the 'any' feature is supported,
  157.      * function opens the service for the zone supporting that feature. If there
  158.      * are only dial-up interfaces, function opens the service for them.
  159.      *
  160.      * @param string service such as "ssh" or "vnc"
  161.      */
  162.     global define void OpenServiceOnNonDialUpInterfaces (string service) {
  163.     list <string> non_dial_up_interfaces = SuSEFirewall::GetAllNonDialUpInterfaces();
  164.     list <string> dial_up_interfaces     = SuSEFirewall::GetAllDialUpInterfaces();
  165.  
  166.     // Opening the service for non-dial-up interfaces
  167.     if (size(non_dial_up_interfaces)>0) {
  168.         list <string> non_dial_up_interfaces_zones = SuSEFirewall::GetZonesOfInterfaces(non_dial_up_interfaces);
  169.         y2milestone("Opening service %1 on interfaces %2 (zones %3)",
  170.         service, non_dial_up_interfaces, non_dial_up_interfaces_zones);
  171.         SuSEFirewall::SetServicesForZones([service], non_dial_up_interfaces_zones, true);
  172.  
  173.     // Only dial-up network interfaces, there mustn't be any non-dial-up one
  174.     } else if (size(dial_up_interfaces) > 0) {
  175.         list <string> dial_up_interfaces_zones = SuSEFirewall::GetZonesOfInterfaces(dial_up_interfaces);
  176.         y2warning("Opening service %1 on interfaces %2 (zones %3)",
  177.         service, dial_up_interfaces, dial_up_interfaces_zones);
  178.         SuSEFirewall::SetServicesForZones([service], dial_up_interfaces_zones, true);
  179.  
  180.     // No network interfaces are known
  181.     } else if (size(known_interfaces) == 0) {
  182.         if (
  183.         SuSEFirewall::IsAnyNetworkInterfaceSupported() &&
  184.         SuSEFirewall::IsServiceSupportedInZone (service, SuSEFirewall::special_all_interface_zone)
  185.         ) {
  186.         y2warning("WARNING: Opening %1 for the External zone without any known interface!", toupper(service));
  187.         SuSEFirewall::SetServicesForZones([service], [SuSEFirewall::special_all_interface_zone], true);
  188.         y2milestone("By now, %1 for %2 zone is %3",
  189.             service,
  190.             SuSEFirewall::special_all_interface_zone,
  191.             SuSEFirewall::IsServiceSupportedInZone (service, SuSEFirewall::special_all_interface_zone)
  192.         );
  193.         }
  194.     }
  195.     }
  196.  
  197.     /**
  198.      * Local function returns whether the Xen kernel is installed
  199.      */
  200.     boolean IsXenInstalled () {
  201.     // bug #154133
  202.     if (Package::Installed ("kernel-xen"))
  203.         return true;
  204.     if (Package::Installed ("kernel-xenpae"))
  205.         return true;
  206.  
  207.     return false;
  208.     }
  209.  
  210.     /**
  211.      * Local function for proposing firewall configuration.
  212.      */
  213.     void ProposeFunctions () {
  214.     list <map <string, string> > known_interfaces = SuSEFirewall::GetAllKnownInterfaces();
  215.  
  216.     list <string> dial_up_interfaces = [];
  217.     list <string> non_dup_interfaces = [];
  218.     foreach (map<string, string> interface, known_interfaces, {
  219.         if (interface["type"]:nil == "dial_up") {
  220.         dial_up_interfaces = add (dial_up_interfaces, interface["id"]:"");
  221.         } else {
  222.         non_dup_interfaces = add (non_dup_interfaces, interface["id"]:"");
  223.         }
  224.     });
  225.  
  226.     y2milestone("Proposal based on configuration: Dial-up interfaces: %1, Other: %2",
  227.         dial_up_interfaces, non_dup_interfaces
  228.     );
  229.  
  230.     // has any network interface
  231.     if (size(non_dup_interfaces)==0 || size(dial_up_interfaces)==0) {
  232.         SuSEFirewall::SetEnableService(ProductFeatures::GetBooleanFeature ("globals", "enable_firewall"));
  233.         SuSEFirewall::SetStartService(ProductFeatures::GetBooleanFeature ("globals", "enable_firewall"));
  234.     }
  235.  
  236.         // has non-dial-up and also dial-up interfaces
  237.         if (size(non_dup_interfaces)>0 && size(dial_up_interfaces)>0) {
  238.         SetInterfacesToZone(non_dup_interfaces, "INT");
  239.         SetInterfacesToZone(dial_up_interfaces, "EXT");
  240.         if (ProductFeatures::GetBooleanFeature ("globals", "firewall_enable_ssh"))
  241.             SuSEFirewall::SetServicesForZones(["ssh"], ["INT","EXT"], true);
  242.  
  243.         // has non-dial-up and doesn't have dial-up interfaces
  244.         } else if (size(non_dup_interfaces)>0 && size(dial_up_interfaces)==0) {
  245.         SetInterfacesToZone(non_dup_interfaces, "EXT");
  246.         if (ProductFeatures::GetBooleanFeature ("globals", "firewall_enable_ssh"))
  247.             SuSEFirewall::SetServicesForZones(["ssh"], ["EXT"], true);
  248.  
  249.         // doesn't have non-dial-up and has dial-up interfaces
  250.         } else if (size(non_dup_interfaces)==0 && size(dial_up_interfaces)>0) {
  251.         SetInterfacesToZone(dial_up_interfaces, "EXT");
  252.         if (ProductFeatures::GetBooleanFeature ("globals", "firewall_enable_ssh"))
  253.             SuSEFirewall::SetServicesForZones(["ssh"], ["EXT"], true);
  254.         }
  255.  
  256.     /*
  257.      * Dial-up interfaces are considered to be internal,
  258.      * Non-dial-up are considered to be external.
  259.      * If there are only Non-dial-up interfaces, they are all considered as external.
  260.      *
  261.      * VNC Installation proposes to open VNC Access up on the Non-dial-up interfaces only.
  262.      * SSH Installation is the same case...
  263.      */
  264.     if (Linuxrc::vnc()) {
  265.         y2milestone("This is an installation over VNC, opening VNC on all non-dial-up interfaces...");
  266.         OpenServiceOnNonDialUpInterfaces("vnc");
  267.     }
  268.     if (Linuxrc::usessh()) {
  269.         y2milestone("This is an installation over SSH, opening SSH on all non-dial-up interfaces...");
  270.         OpenServiceOnNonDialUpInterfaces("ssh");
  271.     }
  272.  
  273.     /*
  274.      * Firewall support for XEN domain0
  275.      */
  276.     if (IsXenInstalled()) {
  277.         y2milestone("Adding Xen support into the firewall configuration");
  278.         SuSEFirewall::AddXenSupport();
  279.     }
  280.  
  281.     SetKnownInterfaces(SuSEFirewall::GetListOfKnownInterfaces());
  282.     }
  283.     
  284.     # <!-- SuSEFirewall LOCAL FUNCTIONS //-->
  285.  
  286.     # <!-- SuSEFirewall GLOBAL FUNCTIONS //-->
  287.  
  288.     /**
  289.      * Function sets that proposal was changed by user
  290.      *
  291.      * @param    boolean if changed by user
  292.      */
  293.     global define void SetChangedByUser (boolean changed) {
  294.     y2milestone("Proposal was changed by user");
  295.     proposal_changed_by_user = changed;
  296.     }
  297.  
  298.     /**
  299.      * Local function returns if proposal was changed by user
  300.      *
  301.      * @return    boolean if proposal was changed by user
  302.      */
  303.     global define boolean GetChangedByUser () {
  304.     return proposal_changed_by_user;
  305.     }
  306.  
  307.     /**
  308.      * Function sets that proposal was initialized
  309.      *
  310.      * @param    boolean if initialized
  311.      */
  312.     global define void SetProposalInitialized (boolean initialized) {
  313.     proposal_initialized = initialized;
  314.     }
  315.  
  316.     /**
  317.      * Local function returns if proposal was initialized already
  318.      *
  319.      * @return    boolean if proposal was initialized
  320.      */
  321.     global define boolean GetProposalInitialized () {
  322.     return proposal_initialized;
  323.     }
  324.  
  325.     /**
  326.      * Function fills up default configuration into internal values
  327.      *
  328.      * @return void
  329.      */
  330.     global define void Reset () {
  331.     SuSEFirewall::ResetReadFlag();
  332.     SuSEFirewall::Read();
  333.     }
  334.  
  335.     /**
  336.      * Function proposes the SuSEfirewall2 configuration
  337.      *
  338.      * @return void
  339.      */
  340.     global define void Propose () {
  341.     // Not changed by user - Propose from scratch
  342.     if (! GetChangedByUser()) {
  343.         y2milestone("Calling firewall configuration proposal");
  344.         Reset();
  345.         ProposeFunctions();
  346.     // Changed - don't break user's configuration
  347.     } else {
  348.         y2milestone("Calling firewall configuration update proposal");
  349.         UpdateProposal();
  350.     }
  351.     }
  352.  
  353.     /**
  354.      * Function returns the proposal summary
  355.      *
  356.      * @return map<string, string> proposal
  357.      * @struct map $[
  358.      *    "output" : "HTML Proposal Summary",
  359.      *    "warning" : "HTML Warning Summary",
  360.      * ]
  361.      */
  362.     global define map<string, string> ProposalSummary () {
  363.     // output: $[ "output" : "HTML Proposal", "warning" : "HTML Warning" ];
  364.     string output  = "";
  365.     string warning = "";
  366.  
  367.     boolean firewall_is_enabled = (SuSEFirewall::GetEnableService() == true);
  368.  
  369.     output = output + "<ul>\n";
  370.     output = output + (firewall_is_enabled ?
  371.         // TRANSLATORS: Proposal informative text "Firewall is enabled" with link around
  372.         // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  373.         _("Firewall is <a href=\"firewall--disable_firewall_in_proposal\">enabled</a>")
  374.         :
  375.         // TRANSLATORS: Proposal informative text "Firewall is disabled" with link around
  376.         // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  377.         _("Firewall is <a href=\"firewall--enable_firewall_in_proposal\">disabled</a>")
  378.     );
  379.  
  380.     if (firewall_is_enabled) {
  381.         // Any enabled SSH means SSH-is-enabled
  382.         boolean is_ssh_enabled = false;
  383.  
  384.         // Any known interfaces
  385.         if (size(known_interfaces)>0) {
  386.         y2milestone("Interfaces: %1", known_interfaces);
  387.  
  388.         // all known interfaces for testing
  389.         list <string> used_zones = SuSEFirewall::GetZonesOfInterfacesWithAnyFeatureSupported(known_interfaces);
  390.         y2milestone("Zones used by firewall: %1", used_zones);
  391.         
  392.         foreach (string zone, used_zones, {
  393.             if (SuSEFirewall::IsServiceSupportedInZone ("ssh", zone)) {
  394.             is_ssh_enabled = true;
  395.             }
  396.         });
  397.  
  398.         output = output + "<br>" + (is_ssh_enabled ?
  399.             // TRANSLATORS: Network proposal informative text with link around
  400.             // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  401.             _("SSH port is <a href=\"firewall--disable_ssh_in_proposal\">open</a>")
  402.             :
  403.             // TRANSLATORS: Network proposal informative text with link around
  404.             // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  405.             _("SSH port is <a href=\"firewall--enable_ssh_in_proposal\">blocked</a>")
  406.         );
  407.  
  408.         // No known interfaces, but 'any' is supported
  409.         // and ssh is enabled there
  410.         } else if (
  411.         SuSEFirewall::IsAnyNetworkInterfaceSupported() &&
  412.         SuSEFirewall::IsServiceSupportedInZone ("ssh", SuSEFirewall::special_all_interface_zone)
  413.         ) {
  414.             is_ssh_enabled = true;
  415.             // TRANSLATORS: Network proposal informative text with link around
  416.             // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  417.             output = output + "<br>" + _("SSH port is <a href=\"firewall--disable_ssh_in_proposal\">open</a>, but there are still no network interfaces configured");
  418.         }
  419.         y2milestone("SSH is " + (is_ssh_enabled ? "":"not ") + "enabled");
  420.  
  421.         if (Linuxrc::usessh()) {
  422.         if (!is_ssh_enabled)
  423.             // TRANSLATORS: This is a warning message. Installation over SSH without SSH allowed on firewall
  424.             AddWarning(_("You are installing a system over SSH, but you have not opened the SSH port on the firewall."));
  425.         }
  426.  
  427.         // when the firewall is enabled and we are installing the system over VNC
  428.         if (Linuxrc::vnc()) {
  429.         // Any enabled VNC means VNC-is-enabled
  430.         boolean is_vnc_enabled = false;
  431.         if (size(known_interfaces)>0) {
  432.             foreach (string zone, SuSEFirewall::GetZonesOfInterfacesWithAnyFeatureSupported(known_interfaces), {
  433.             if (SuSEFirewall::IsServiceSupportedInZone ("vnc", zone))
  434.                 is_vnc_enabled = true;
  435.             });
  436.         }
  437.         y2milestone("VNC port is " + (is_vnc_enabled ? "open":"blocked") + " in the firewall");
  438.  
  439.         output = output + "<br>" + (is_vnc_enabled ?
  440.             // TRANSLATORS: Network proposal informative text "Remote Administration (VNC) is enabled" with link around
  441.             // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  442.             _("Remote Administration (VNC) ports are <a href=\"firewall--disable_vnc_in_proposal\">open</a>")
  443.             :
  444.             // TRANSLATORS: Network proposal informative text "Remote Administration (VNC) is disabled" with link around
  445.             // IMPORTANT: Please, do not change the HTML link <a href="...">...</a>, only visible text
  446.             _("Remote Administration (VNC) ports are <a href=\"firewall--enable_vnc_in_proposal\">blocked</a>")
  447.         );
  448.  
  449.         if (!is_vnc_enabled)
  450.             // TRANSLATORS: This is a warning message. Installation over VNC without VNC allowed on firewall
  451.             AddWarning(_("You are installing a system using remote administration (VNC), but you have not opened the VNC ports on the firewall."));
  452.         }
  453.         
  454.         list <string> warnings_strings = GetWarnings();
  455.         if (size(warnings_strings)>0) {
  456.         ClearWarnings();
  457.         foreach (string single_warning, warnings_strings, {
  458.             warning = warning + "<li>" + single_warning + "</li>\n";
  459.         });
  460.         warning = "<ul>\n" + warning + "</ul>\n";
  461.         }
  462.     }
  463.  
  464.     output = output + "</ul>\n";
  465.  
  466.     return $[
  467.         "output"        : output,
  468.         "warning"        : warning,
  469.     ];
  470.     }
  471.  
  472.     # <!-- SuSEFirewall GLOBAL FUNCTIONS //-->
  473.  
  474. /* EOF */
  475. }
  476.