DouKaku? 9113 yamamoto: とりあえず、InetAddressを使い...(IPv4アドレスのマスクの変換)

Comment detail

とりあえず、InetAddressを使いました。例外処理があるので効率は・・・・

import java.net._

object IPNetMask {
  val ipMask2NumBits = Map(
       (256-  1) -> 8 ,
       (256-  2) -> 7 ,
       (256-  4) -> 6 ,
       (256-  8) -> 5 ,
       (256- 16) -> 4 ,
       (256- 32) -> 3 ,
       (256- 64) -> 2 ,
       (256-128) -> 1 ,
               0 -> 0 )
  var ipNumBits2Mask = Map[Int,Int]()
  for( (k,v)<-ipMask2NumBits ) ipNumBits2Mask += v->k
  
  def main(args : Array[String]) : Unit = {
    //ipMask2NumBits.foreach(println _)
    //ipNumBits2Mask.foreach(println _)
    
    for{ arg <-args
         ip  =InetAddress.getByName(arg) }{
      ip2numbits(ip) match {
        case Some(n) =>
          println(ip+" : " +n+"bits")
          println("reverse : "+numbits2ip(n))
        case None => println("error")
      }
    }
    
    ()
  }
  def ip2numbits(ip:InetAddress) : Option[Int] = {
    val rawIP = ip.getAddress.map(0x0FF & _)
    try{
      rawIP match{
        case Seq(255,255,255,a) => return Some( 24 + ipMask2NumBits(a) )
        case Seq(255,255,  a,0) => return Some( 16 + ipMask2NumBits(a) )
        case Seq(255,  a,  0,0) => return Some(  8 + ipMask2NumBits(a))
        case _ => return None
      }
    }catch{
      case _ => return None
    }
    None
  }
  
  def numbits2ip(numbits:Int) : Option[InetAddress]={
    try{
      numbits match {
        case n if (n >= 24) => return Some(InetAddress.getByName( ipNumBits2Mask(n-24).formatted("255.255.255.%d")))
        case n if (n >= 16) => return Some(InetAddress.getByName( ipNumBits2Mask(n-16).formatted("255.255.%d.0")))
        case n if (n >=  8) => return Some(InetAddress.getByName( ipNumBits2Mask(n- 8).formatted("255.%d.0.0")))
      }
    }catch{
      case _ => return None
    }
    None
  }
}

Scala(#9133)をErlangに移植しました。効率はともかく、例外処理をしているので・・・

関数の仕様は、Erlang的で、成功時は {ok,****} のようなタプルが返ります。失敗時はok以外のアトム。

-module(netmask).
-export([numbits_of/1,from_numbits/1,test/0]).

numbits_of(StrMask) -> 
    try
        {ok,Mask} = inet_parse:address(StrMask) ,
        {Class,MaskByte} = case Mask of
                        {255,255,255,X} -> {24,X};
                        {255,255,  X,0} -> {16,X};
                        {255,  X,  0,0} -> { 8,X};
                        _ -> throw("bad mask")
                        end,
        {ok,
        case MaskByte of
            (256-  1)-> 8;
            (256-  2)-> 7;
            (256-  4)-> 6;
            (256-  8)-> 5;
            (256- 16)-> 4;
            (256- 32)-> 3;
            (256- 64)-> 2;
            (256-128)-> 1;
            0        -> 0
        end + Class }% <--- result
    catch
        throw:E -> {thrown,E};
        exit :E -> {exited,E};
        error:E -> {error ,E}
    end.

from_numbits(Numbits)->
    try
        {Class,Maskbits} = 
                        case Numbits of
                            N when N>=24 -> {24,N-24} ;
                            N when N>=16 -> {16,N-16} ;
                            N when N>= 8 -> { 8,N- 8} 
                        end ,
        Maskbyte = 
                case Maskbits of 
                    8 -> (256-  1) ;
                    7 -> (256-  2) ;
                    6 -> (256-  4) ;
                    5 -> (256-  8) ;
                    4 -> (256- 16) ;
                    3 -> (256- 32) ;
                    2 -> (256- 64) ;
                    1 -> (256-128) ;
                    0 -> 0
                end ,
        %
        {ok , 
        case Class of
            24 -> inet_parse:ntoa( {255,255,255,Maskbyte} ) ;
            16 -> inet_parse:ntoa( {255,255,Maskbyte  ,0} ) ;
            8  -> inet_parse:ntoa( {255,Maskbyte    ,0,0} ) 
        end }% <--- result
    catch
        throw:E -> {thrown,E};
        exit :E -> {exited,E};
        error:E -> {error ,E}
    end.

test()->
    lists:foreach(fun(I)->
                    {ok , M} = from_numbits(I),
                    {ok , N} = numbits_of(M),
                    io:format("Numbits=~p , Mask=~p , Result=~p~n",[I,M,(I==N)])
                  end , lists:seq(8,31) ).

DouKaku?

Comment detail

Index

Feed

Other

Link

Pathtraq