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 / IP.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  6.3 KB  |  238 lines
  1. /**
  2.  * File:    modules/IP.ycp
  3.  * Module:    yast2
  4.  * Summary:    IP manipulation routines
  5.  * Authors:    Michal Svec <msvec@suse.cz>
  6.  * Flags:    Stable
  7.  *
  8.  * $Id: IP.ycp 33164 2006-09-27 08:42:24Z jsrain $
  9.  */
  10.  
  11. {
  12.  
  13. module "IP";
  14. textdomain "base";
  15.  
  16. global string ValidChars = "0123456789abcdefABCDEF.:";
  17. global string ValidChars4 = "0123456789.";
  18. global string ValidChars6 = "0123456789abcdefABCDEF:";
  19.  
  20. /**
  21.  * Describe a valid IPv4 address
  22.  * @return string describtion a valid IPv4 address
  23.  */
  24. global define string Valid4() ``{
  25.     //Translators: dot: "."
  26.     return _("A valid IP address consists of four integers
  27. in the range 0-255 separated by dots.");
  28. }
  29.  
  30. /**
  31.  * Check syntax of IPv4 address
  32.  * @param ip IPv4 address
  33.  * @return true if correct
  34.  */
  35. global define boolean Check4(string ip) ``{
  36.     if(ip == nil || ip == "") return false;
  37.     string num = "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
  38.     string ipv4 = "^" + num + "(\\." + num + "){3}$";
  39.     return regexpmatch(ip, ipv4);
  40. }
  41.  
  42. /*
  43.  * Check syntax of IPv4 address (maybe better)
  44.  * @param ip IPv4 address
  45.  * @return true if correct
  46.  */
  47. /*
  48. global defin boolean Check4_new(string ip) ``{
  49.     if(ip == nil || ip == "") return false;
  50.     string num0 = "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[1-9])";
  51.     string num1 = "(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
  52.     string ipv4 = "^" + num0 + "(\\." + num1 + "){3}$";
  53.     return regexpmatch(ip, ipv4);
  54. }
  55. */
  56.  
  57. /**
  58.  * Check syntax of IPv6 address
  59.  * @param ip IPv6 address
  60.  * @return true if correct
  61.  */
  62. global define boolean Check6(string ip) ``{
  63.     if(ip == nil || ip == "") return false;
  64.  
  65.     //string num = "([1-9a-fA-F][0-9a-fA-F]*|0)";
  66.     string num = "([0-9a-fA-F]{1,4})";
  67.  
  68.     /* 1:2:3:4:5:6:7:8 */
  69.     if(regexpmatch(ip, "^" + num + "(:" + num + "){7}$")) return true;
  70.     /* ::3:4:5:6:7:8 */
  71.     if(regexpmatch(ip, "^:(:" + num + "){1,6}$")) return true;
  72.     /* 1:2:3:4:5:6:: */
  73.     if(regexpmatch(ip, "^(" + num + ":){1,6}:$")) return true;
  74.     /* :: only once */
  75.     if(regexpmatch(ip, "::.*::")) return false;
  76.     /* : max 7x */
  77.     if(regexpmatch(ip, "^([^:]*:){8,}")) return false;
  78.     /* 1:2:3::5:6:7:8 */
  79.     /* 1:2:3:4:5:6::8 */
  80.     if(regexpmatch(ip, "^(" + num + ":){1,6}(:" + num + "){1,6}$")) return true;
  81.  
  82.     return false;
  83. }
  84.  
  85. /**
  86.  * Check syntax of IP address
  87.  * @param ip IP address
  88.  * @return true if correct
  89.  */
  90. global define boolean Check(string ip) ``{
  91.     return Check4(ip) || Check6(ip);
  92. }
  93.  
  94.  
  95. /**
  96.  * Convert IPv4 address from string to integer
  97.  * @param ip IPv4 address
  98.  * @return ip address as integer
  99.  */
  100. global define integer ToInteger(string ip) ``{
  101.     /* FIXME: Check4, also to Compute* */
  102.     list l = maplist(string e, splitstring(ip, "."), ``(tointeger(e)));
  103.     return l[3]:0 + (l[2]:0<<8) + (l[1]:0<<16) + (l[0]:0<<24);
  104. }
  105.  
  106. /**
  107.  * Convert IPv4 address from integer to string
  108.  * @param ip IPv4 address
  109.  * @return ip address as string
  110.  */
  111. global define string ToString(integer ip) ``{
  112.     list l = maplist(integer b, [0x1000000, 0x10000, 0x100, 0x1], ``((ip / b) & 0xff));
  113.     return sformat("%1.%2.%3.%4", l[0]:0, l[1]:0, l[2]:0, l[3]:0);
  114. }
  115.  
  116. /**
  117.  * Converts IPv4 address from string to hex format
  118.  * @param ip IPv4 address as string in "ipv4" format
  119.  * @return string representing IP in Hex
  120.  * @example IP::ToHex("192.168.1.1") -> "0xC0A80101"
  121.  * @example IP::ToHex("10.10.0.1") -> "0x0A0A0001"
  122.  */
  123. global define string ToHex(string ip) ``{
  124.     string tmp = "00000000" + substring(toupper(tohexstring(ToInteger(ip))), 2);
  125.     return substring(tmp, size(tmp) - 8);
  126. }
  127.  
  128. /**
  129.  * Compute IPv4 network address from ip4 address and network mask.
  130.  * @param ip IPv4 address
  131.  * @param mask netmask
  132.  * @return computed subnet
  133.  */
  134. global define string ComputeNetwork(string ip, string mask) ``{
  135.     integer i = ToInteger(ip);
  136.     integer m = ToInteger(mask);
  137.     return ToString((i & m) & 0xffffffff);
  138. }
  139.  
  140. /**
  141.  * Compute IPv4 broadcast address from ip4 address and network mask.
  142.  *
  143.  * The broadcast address is the highest address of network address range.
  144.  * @param ip IPv4 address
  145.  * @param mask netmask
  146.  * @return computed broadcast
  147.  */
  148. global define string ComputeBroadcast(string ip, string mask) ``{
  149.     integer i = ToInteger(ip);
  150.     integer m = ToInteger(mask);
  151.     return ToString((i | ~m) & 0xffffffff);
  152. }
  153.  
  154. // helper list, each bit has its decimal representation
  155. list <integer> bit_weight_row = [128, 64, 32, 16, 8, 4, 2, 1];
  156.  
  157. /**
  158.  * Converts IPv4 into its 32 bit binary representation.
  159.  *
  160.  * @param string ipv4
  161.  * @return string binary
  162.  *
  163.  * @see BitsToIPv4()
  164.  *
  165.  * @example
  166.  *     IPv4ToBits("80.25.135.2")    -> "01010000000110011000011100000010"
  167.  *     IPv4ToBits("172.24.233.211") -> "10101100000110001110100111010011"
  168.  */
  169. global string IPv4ToBits (string ipv4) {
  170.     if (!Check4(ipv4)) {
  171.         y2error("Not a valid IPv4: %1", ipv4);
  172.         return nil;
  173.     }
  174.     
  175.     string ret = "";
  176.     foreach (string ipv4_part, splitstring(ipv4, "."), {
  177.         integer ipv4_part_i = tointeger(ipv4_part);
  178.         foreach (integer try_i, bit_weight_row, {
  179.             if ((ipv4_part_i / try_i) > 0) {
  180.                 ipv4_part_i = ipv4_part_i % try_i;
  181.                 ret = ret + "1";
  182.             } else {
  183.                 ret = ret + "0";
  184.             }
  185.         });
  186.     });
  187.     
  188.     return ret;
  189. }
  190.  
  191. /**
  192.  * Converts 32 bit binary number to its IPv4 repserentation.
  193.  *
  194.  * @param string binary
  195.  * @return string ipv4
  196.  *
  197.  * @see IPv4ToBits()
  198.  *
  199.  * @example
  200.  *     BitsToIPv4("10111100000110001110001100000101") -> "188.24.227.5"
  201.  *     BitsToIPv4("00110101000110001110001001100101") -> "53.24.226.101"
  202.  */
  203. global string BitsToIPv4 (string bits) {
  204.     if (size(bits) != 32) {
  205.         y2error("Not a valid IPv4 in Bits: %1", bits);
  206.         return nil;
  207.     }
  208.     if (!regexpmatch(bits, "^[01]+$")) {
  209.         y2error("Not a valid IPv4 in Bits: %1", bits);
  210.         return nil;
  211.     }
  212.  
  213.     string ipv4 = "";
  214.     integer position = 0;
  215.     while (position < 32) {
  216.         integer ip_part = 0;
  217.         string eight_bits = substring (bits, position, 8);
  218.  
  219.         integer counter = -1;
  220.         while (counter < 8) {
  221.             counter = counter + 1;
  222.             string one_bit = substring (eight_bits, counter, 1);
  223.  
  224.             if (one_bit == "1") {
  225.                 ip_part = ip_part + bit_weight_row[counter]:0;
  226.             }
  227.         };
  228.  
  229.         ipv4 = ipv4 + (ipv4 != "" ? ".":"") + tostring(ip_part);
  230.         position = position + 8;
  231.     }
  232.     
  233.     return ipv4;
  234. }
  235.  
  236. /* EOF */
  237. }
  238.