Pages

Thursday, January 16, 2014

TCL procs

Ip address increment :
proc generate_ips {start_ip number_of_ips} {
    regexp {([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)} $start_ip - oct1 oct2 oct3 oct4
    set ip_list ""
    while {[llength $ip_list] < $number_of_ips} {
        for {} {$oct4 <= 254} {incr oct4} {
            lappend ip_list "$oct1.$oct2.$oct3.$oct4"
            if {[llength $ip_list] == $number_of_ips} {
                break
            }
        }
        if {$oct4 == 255} {
            set oct4 0
            incr oct3
        }
        if {$oct3 == 256} {
            set oct3 0
            incr oct2
        }
        if {$oct2 == 256} {
            set oct2 0
            incr oct1
        }
        if {$oct1 == 256} {
            break
        }
    }
    return $ip_list
}
set start_ip "103.0.0.2"
set ip_list [generate_ips $start_ip 5]
puts $ip_list
puts [llength $ip_list]

In python:
Here's a Python program that prints 1000 IPv4 addresses in incremental fashion:

```python
def print_ipv4_addresses(start_ip="192.168.0.1", count=1000):
    # Split the start IP address into octets
    parts = start_ip.split('.')
    octets = [int(part) for part in parts]

    # Loop through the count of IPv4 addresses
    for _ in range(count):
        # Print the current IP address
        print('.'.join(map(str, octets)))

        # Increment the last octet
        octets[3] += 1

        # Adjust other octets if necessary
        for i in range(3, 0, -1):
            if octets[i] > 255:
                octets[i] = 0
                octets[i - 1] += 1
            else:
                break

# Call the function to print IPv4 addresses
print_ipv4_addresses()
```

This program defines a function `print_ipv4_addresses` that takes two optional parameters: `start_ip` (the starting IPv4 address, default is "192.168.0.1") and `count` (the number of IPv4 addresses to print, default is 1000).

The function splits the starting IP address into octets and increments them in a loop while printing the resulting IPv4 addresses. If an octet exceeds 255, it rolls over to 0 and the next octet is incremented accordingly. This process continues until the desired number of IPv4 addresses are printed.


mac address increment :

proc generate_mac {start_mac number_of_mac} {
    regexp {([0-9a-fA-F]+)([0-9a-fA-F]+)\:([0-9a-fA-F]+)([0-9a-fA-F]+)\:([0-9a-fA-F]+)([0-9a-fA-F]+)\:([0-9a-fA-F]+)([0-9a-fA-F]+)\:([0-9a-fA-F]+)([0-9a-fA-F]+)\:([0-9a-fA-F]+)([0-9a-fA-F]+)} $start_mac - hex1 hex2 hex3 hex4 hex5 hex6 hex7 hex8 hex9 hex10 hex11 hex12
    set mac_list ""
    array set hex_list {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 A 11 B 12 C 13 D 14 E 15 F 16 16}
    array set hex_list {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 a 11 b 12 c 13 d 14 e 15 f 16 16}
    array set dec_list {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 A 10 B 11 C 12 D 13 E 14 F 15} 
    array set dec_list {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 a 10 b 11 c 12 d 13 e 14 f 15}
    set hex12 $dec_list($hex12)
    while {[llength $mac_list] < $number_of_mac} {
        for {} {$hex12 <= 15} {incr hex12} {
            set hex12_new $hex_list($hex12)
            lappend mac_list "$hex1$hex2:$hex3$hex4:$hex5$hex6:$hex7$hex8:$hex9$hex10:$hex11$hex12_new"
            if {[llength $mac_list] == $number_of_mac} {
                break
            }
        }
        if {$hex12 == 16} {
            set hex12 0
            set hex11 $dec_list($hex11)
            incr hex11
            set hex11 $hex_list($hex11)
        }
        if {$hex11 == 16} {
            set hex11 0
            set hex10 $dec_list($hex10)
            incr hex10
            set hex10 $hex_list($hex10)
        }
        if {$hex10 == 16} {
            set hex10 0
            set hex9 $dec_list($hex9)
            incr hex9
            set hex9 $hex_list($hex9)
        }
        if {$hex9 == 16} {
            set hex9 0
            set hex8 $dec_list($hex8)
            incr hex8
            set hex8 $hex_list($hex8)
        }
        if {$hex8 == 16} {
            set hex8 0
            set hex7 $dec_list($hex7)
            incr hex7
            set hex7 $hex_list($hex7)
        }
        if {$hex7 == 16} {
            set hex7 0
            set hex6 $dec_list($hex6)
            incr hex6
            set hex6 $hex_list($hex6)
        }
        if {$hex6 == 16} {
            set hex6 0
            set hex5 $dec_list($hex5)
            incr hex5
            set hex5 $hex_list($hex5)
        }
        if {$hex5 == 16} {
            set hex5 0
            set hex4 $dec_list($hex4)
            incr hex4
            set hex4 $hex_list($hex4)
        }
        if {$hex4 == 16} {
            set hex4 0
            set hex3 $dec_list($hex3)
            incr hex3
            set hex3 $hex_list($hex3)
        }
        if {$hex3 == 16} {
            set hex3 0
            set hex2 $dec_list($hex2)
            incr hex2
            set hex2 $hex_list($hex2)
        }
        if {$hex2 == 16} {
            set hex2 0
            set hex1 $dec_list($hex1)
            incr hex1
            set hex1 $hex_list($hex1)
        }
        if {$hex1 == 16} {
            break
        }
    }
    return $mac_list
}
set start_mac "10:ef:09:14:a0:7e"
set mac_list [generate_mac $start_mac 100]
puts $mac_list
puts [llength $mac_list]


In Python:

Here's a Python program that increments a MAC address:

```python
def increment_mac_address(mac_address):
    # Split MAC address into octets
    octets = mac_address.split(':')

    # Convert each octet to an integer
    for i in range(len(octets)):
        octets[i] = int(octets[i], 16)

    # Increment the last octet
    octets[-1] += 1

    # Handle carry-over if necessary
    for i in range(len(octets) - 1, 0, -1):
        if octets[i] > 255:
            octets[i] = octets[i] % 256
            octets[i - 1] += 1
        else:
            break

    # Convert octets back to hexadecimal string format
    incremented_mac = ':'.join([format(octet, '02x') for octet in octets])

    return incremented_mac

# Example usage
original_mac = '00:11:22:33:44:ff'
incremented_mac = increment_mac_address(original_mac)
print("Original MAC address:", original_mac)
print("Incremented MAC address:", incremented_mac)
```

This program defines a function `increment_mac_address` that takes a MAC address as input and returns the incremented MAC address. The function splits the MAC address into octets, increments the last octet, and handles carry-over if necessary. Finally, it converts the octets back to hexadecimal string format and returns the incremented MAC address.

You can call this function with a MAC address as input to increment it.

No comments:

Post a Comment