IPv6

[JRSmile]

Hi there im currently learning for my exams and this is what i came up with implementing the mapping function of the rfc conform ipv4 to ipv6 conversion.

expandcollapse popup

#include <string.au3>
ConsoleWrite(@IPAddress4 & @CRLF)
ConsoleWrite(__CIDR2Dotted(96) & @CRLF)
ConsoleWrite(__bitmask2IP(_StringRepeat("0",80)&_StringRepeat("1",16) & ip2bit(@IPAddress4)) & @CRLF)


Func ip2bit($ip)
    $tmp2 = StringSplit($ip,".", 1)
    Local $tmp4
    for $i = 1 to $tmp2[0]
        $tmp3 = Hex($tmp2[$i],2)
        $tmp3 = StringSplit($tmp3,"",1)
        $tmp4 &= cov($tmp3[1]) & cov($tmp3[2])
        
    Next
    Return $tmp4
EndFunc

Func cov($hex)
    Switch $hex
        Case "0"
            Return "0000"
        Case "1"
            Return "0001"
        Case "2"
            Return "0010"
        Case "3"
            Return "0011"
        Case "4"
            Return "0100"
        Case "5"
            Return "0101"
        Case "6"
            Return "0110"
        Case "7"
            Return "0111"
        Case "8"
            Return "1000"
        Case "9"
            Return "1001"
        Case "A"
            Return "1010"
        Case "B"
            Return "1011"
        Case "C"
            Return "1100"
        Case "D"
            Return "1101"
        Case "E"
            Return "1110"
        Case "F"
            Return "1111"
    EndSwitch
EndFunc

Func __CIDR2Dotted($cidr)
    $part = _StringRepeat("1",$cidr)
    Return __bitmask2IP($part)
EndFunc

Func __bitmask2IP($string)
    $string = StringStripWS($string,8)
    Local $res = ""
    $string = $string & StringTrimLeft(_StringRepeat("0",128), StringLen($string))
    ConsoleWrite($string & @CRLF)
    for $i = 1 to StringLen($string) step 16
        $part = StringMid($string,$i,16)
        $res &= conv_part($part) & ":"
    Next
    Return StringTrimRight($res,1)
EndFunc



Func conv_part($src)
    if StringLen($src) <> 16 then Return SetError(1,0,False)
    if not IsString($src) Then Return SetError(1,0,False)
    $src = StringSplit($src,"", 1)
    Local $res = 0
    for $i = 1 to 16
        $res += 2^(16-$i) * $src[$i]
    Next
    Return Hex($res,4)
EndFunc

i think its nasty and universes far away from beeing perfect, if somebody has a plan how to improove my funcs, maybe with math, and explain a bit about bit operation i would be glad.

Best regards,

JR.

[rogdog]

a short func here for you

Func cov($Hex)
    Local $aVals[16] = ["0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"]
    Return $aVals[Dec($Hex)]
EndFunc

[JRSmile]

i did a even more dirty implementation

Func small_conv($ip)
    $ip = StringSplit($ip, ".", 1)
    Return "0000:0000:0000:0000:0000:FFFF:" & Hex($ip[1], 2) & Hex($ip[2], 2) & ":" & Hex($ip[3], 2) & Hex($ip[4], 2) & "/96"
EndFunc   ;==>small_conv

but this is crap

[ptrex]

@JRSMile

I had this on my to do list, but never came around starting it.

I did some quick checks for an IP address : 10.0.0.71

On the client it reads, using IPCONFIG : fe80::20f:b0ff:fe40:ca8f%5

On the online convertor I other data ?

Online Convertor

This address is an IPv4 address:

IP v4 :

decimal : 10.0.0.71

binary : 00001010000000000000000001000111

octal : 012.00.00.0107

hexadecimal : 0x0A.0x00.0x00.0x47

long : 167772231

IP v6 :

6 to 4 address : 2002:A00:47:0:0:0:0:0

: 2002:A00:47::

IPv4-mapped address : 0:0:0:0:0:FFFF:10.0.0.71

: ::FFFF:10.0.0.71

: ::FFFF:0A00:0047

IPv4-compatibility address : 0:0:0:0:0:0:10.0.0.71

: ::10.0.0.71

: ::0A00:0047

So there seems to be different type of notations going round ?

Which makes it more confusing.

Regards

ptrex

[JRSmile]

there is just one standart definded in http://tools.ietf.org/html/rfc4291#section-2.5.5

the rest is more ore less "weak acceptance".

there was an old but deprecated way to map ips just leave the first 96 bytes empty and add the ipv4 behind...

but this got declined later.

you now have to send 80bytes of zeros 16 bytes of ones and then the ipv4 address as hex value spread over two WORDs.

so you can implement it correctly << fortunately otherwise there won't be any implementation at all