PF型ファイアウォール ーアプリ
ケーション機能編ー
関連ソースコード
PFSaver\PFSaver.java
PFSaver\ZipCompresser.java
PFSaver\ZipDecompresser.java
ここでは作成したライブラリを利用したアプリケーションを作成する為に、アプリケーションとして備えたい機能群を説明します。
これらの機能群を実装すれば、CUIもしくはGUIアプリケーションが作成できます。
/*194*/ private ArrayList handleList = new ArrayList();
/*195*/ private ArrayList filterList = new ArrayList();
/*196*/ public static final String fExtension = ".flt"; // フィルタ拡張子
/*197*/ public static final String hExtension = ".hdl"; // ハンドル拡張子
/*198*/ private static final String typefile = "TYPE";
/*199*/ private static final String BLACK = "BLACK_LIST";
/*200*/ private static final String WHITE = "WHITE_LIST";
/*201*/ private boolean isWorking; // フィルタリングが動作中かどうか
フィールドです。
194、195行目はメモリ上のハンドルとフィルタを管理する配列です。
196、197行目はハンドルとフィルタをハードディスクに保存する際の拡張子です。(extension : 拡張子)
198行目はハンドルの種類（ブラックリストorホワイトリスト）を保存する際のファイル名です。
199、200行目はTYPEファイルの中に記述する文字列です。どちらがTYPEファイル内に書かれているかによってハンドルを再現します。
201行目はフィルタリングが動作中かどうかを示すブール値です。前回作成したライブラリ内ではフィルタリン実行メソッドはフィルタリング実行中でも呼び
出しは可能なため、こちらで実行状況を管理します。
/*203*/ // コンストラクタ
/*204*/ public PFSaver()
/*205*/ {
/*206*/ isWorking = false;
/*207*/ } // PFSaver END
/*208*/
/*209*/ // フィルタリングを開始する
/*210*/ public void startFiltering(InetAddress adrs, int inH, int outH)
/*211*/ throws PacketFilteringException
/*212*/ {
/*213*/ int adrsType;
/*214*/
/*215*/ if(adrs.getAddress().length==4)
/*216*/ adrsType = PacketFiltering.IPv4_FLAG;
/*217*/ else if(adrs.getAddress().length==16)
/*218*/ adrsType = PacketFiltering.IPv6_FLAG;
/*219*/ else
/*220*/ throw new PacketFilteringException("Unexpected Error");
/*221*/
/*222*/ PacketFiltering.BindInterfaceToIPAddress(adrs, adrsType,
/*223*/ (INTERFACE_HANDLE)(handleList.get(inH)),
/*224*/ (INTERFACE_HANDLE)(handleList.get(outH)));
/*225*/
/*226*/ isWorking = true;
/*227*/ } // startFiltering END
/*228*/
/*229*/ // フィルタリングを停止する
/*230*/ public void stopFiltering() throws PacketFilteringException
/*231*/ {
/*232*/ PacketFiltering.UnBindInterface();
/*233*/ isWorking = false;
/*234*/ } // stopFiltering END
/*235*/
/*236*/ // フィルタリンが動作中かどうか
/*237*/ public boolean isWorking()
/*238*/ {
/*239*/ return isWorking;
/*240*/ } // isWorking END
アプリケーションの為の中心となる機能です。フィルタリングの開始や停止などのメソッドです。
/*242*/ // 前回終了時リストを復元する
/*243*/ public void restoreList(String path) throws Exception
/*244*/ {
/*245*/ Exception excp = null;
/*246*/
/*247*/ String[] hlist = searchHandle(path);
/*248*/ for(int i=0;i<hlist.length;i++)
/*249*/ {
/*250*/ if(DEBUG) System.out.println(path+"\\"+hlist[i]); // デバッグ
/*251*/ try
/*252*/ {
/*253*/ readInterfaceHandle(path+"\\"+hlist[i]);
/*254*/ deleteHandle(path+"\\"+hlist[i]);
/*255*/ }
/*256*/ catch(Exception e)
/*257*/ {
/*258*/ excp = e;
/*259*/ }
/*260*/ }
/*261*/
/*262*/ String[] flist = searchFilter(path);
/*263*/ for(int i=0;i<flist.length;i++)
/*264*/ {
/*265*/ if(DEBUG) System.out.println(path+"\\"+flist[i]); // デバッグ
/*266*/ try
/*267*/ {
/*268*/ readFilterDescriptor(path+"\\"+flist[i]);
/*269*/ deleteFilter(path+"\\"+flist[i]);
/*270*/ }
/*271*/ catch(Exception e)
/*272*/ {
/*273*/ excp = e;
/*274*/ }
/*275*/ }
/*276*/
/*277*/ if(excp!=null)
/*278*/ {
/*279*/ throw excp;
/*280*/ }
/*281*/ } // restoreList END
/*282*/
/*283*/ // ハンドル・フィルタのリストを記録する
/*284*/ public void recordList(String path) throws IOException, Exception
/*285*/ {
/*286*/ for(int i=0;i<handleList.size();i++)
/*287*/ {
/*288*/ writeInterfaceHandle(path+"\\handle"+i, i);
/*289*/ }
/*290*/
/*291*/ for(int i=0;i<filterList.size();i++)
/*292*/ {
/*293*/ writeFilterDescriptor(path+"\\filter"+i, i);
/*294*/ }
/*295*/ } // recordMemory END
これらはアプリケーション実行時に前回の終了時のハンドルなどを復元するメソッドです。終了時に記録、起動時にそれらを読み込みます。フィルタリングを実
行しながらアプリケーションを終了してもフィルタリングはアプリケーション起動時に自動で再開されません。
/*299*/ // リストにインタフェースハンドルを追加する
/*300*/ private void addHandle(INTERFACE_HANDLE handle)
/*301*/ {
/*302*/ handleList.add(handle);
/*303*/ } // addHandle END
/*304*/
/*305*/ // リストにブラックリスト・ハンドルを追加する
/*306*/ public void addBlackListHandle()
/*307*/ {
/*308*/ addHandle(INTERFACE_HANDLE.makeBLACK_LIST());
/*309*/ } // addBlackListHandle END
/*310*/
/*311*/ // リストにホワイトリスト・ハンドルを追加する
/*312*/ public void addWhiteListHandle()
/*313*/ {
/*314*/ addHandle(INTERFACE_HANDLE.makeWHITE_LIST());
/*315*/ } // addWhiteListHandle END
/*316*/
/*317*/ // リストからインタフェースハンドルを取り除く
/*318*/ public void removeHandle(int index)
/*319*/ {
/*320*/ handleList.remove(index);
/*321*/ } // removeHandle END
/*322*/
/*323*/ // インタフェースハンドルリストをクリアする
/*324*/ public void clearHandle()
/*325*/ {
/*326*/ handleList.clear();
/*327*/ } // clearHandle END
/*328*/
/*329*/ // リストのハンドル数を得る
/*330*/ public int getHandleNum()
/*331*/ {
/*332*/ return handleList.size();
/*333*/ } // getHandleNum END
/*334*/
/*335*/ // フィルタをインタフェースハンドルにセットする
/*336*/ public void setFilterToHandle(int Hindex, int Findex)
/*337*/ {
/*338*/ ((INTERFACE_HANDLE)(handleList.get(Hindex))).addFilter(
/*339*/ (FILTER_DESCRIPTOR)(filterList.get(Findex)));
/*340*/ } // setFilterToHandle END
/*341*/
/*342*/ // リストのハンドルからフィルタを削除する
/*343*/ public void removeFilterFromHandle(int hIndex, int fIndex)
/*344*/ {
/*345*/ ((INTERFACE_HANDLE)(handleList.get(hIndex))).removeFilter(fIndex);
/*346*/ } // removeFilterFromHandle END
これらはハンドル関連のメソッドです。
/*348*/ // インタフェースハンドルをファイルに書き込む
/*349*/ public void writeInterfaceHandle(String filename, int index) throws IOException
/*350*/ {
/*351*/ INTERFACE_HANDLE handle = (INTERFACE_HANDLE)(handleList.get(index));
/*352*/ ZipCompresser zipper = new ZipCompresser(filename+hExtension);
/*353*/
/*354*/ // ルールファイルの生成
/*355*/ if(handle.rule==INTERFACE_HANDLE.BLACK_LIST)
/*356*/ {
/*357*/ zipper.addFileInZip((Object)BLACK, typefile);
/*358*/ }
/*359*/ else if(handle.rule==INTERFACE_HANDLE.WHITE_LIST)
/*360*/ {
/*361*/ zipper.addFileInZip((Object)WHITE, typefile);
/*362*/ }
/*363*/
/*364*/ // フィルタの書き込み
/*365*/ for(int i=0;i<handle.getSize();i++)
/*366*/ {
/*367*/ zipper.addFileInZip((FILTER_DESCRIPTOR)(handle.getFilter(i)),
/*368*/ "filterfile"+i+fExtension);
/*369*/ }
/*370*/
/*371*/ zipper.close();
/*372*/ } // writeInterfaceHandle END
インタフェースハンドルをファイルに書き込むメソッドです。ハンドルはzip形式で保存され、中にフィルタを保存します。
ZipCompresser.java
(補助クラス)
/* 16*/ private ZipOutputStream zout = null;
/* 17*/ private ObjectOutputStream oout = null;
/* 20*/ public ZipCompresser(String zippath) throws IOException
/* 21*/ {
/* 22*/ zout = new ZipOutputStream(new FileOutputStream( new File(zippath) ));
/* 23*/ }
/* 49*/ public void addFileInZip(Object obj, String filename) throws IOException
/* 50*/ {
/* 51*/ zout.putNextEntry(new ZipEntry(filename));
/* 52*/ oout = new ObjectOutputStream(zout);
/* 53*/ oout.writeObject(obj);
/* 54*/ }
/* 55*/
/* 56*/ public void close() throws IOException
/* 57*/ {
/* 58*/ zout.close();
/* 59*/ if(oout!=null) oout.close();
/* 60*/ }
ハンドルファイル書き込み時に使うzipファイル関連メソッドです。別クラスに記述しています。
49〜57行目はJavaオブジェクトをそのまま書き込むメソッドです。フィルタはオブジェクトのまま保存します。
/*374*/ // インタフェースハンドルファイルを読み込む
/*375*/ public void readInterfaceHandle(String filename)
/*376*/ throws IOException, ClassNotFoundException, Exception
/*377*/ {
/*378*/ INTERFACE_HANDLE handle;
/*379*/
/*380*/ ZipFile zipfile = new ZipFile(filename);
/*381*/
/*382*/ // ハンドルタイプの設定
/*383*/ String type = getHandleFileType(zipfile);
/*384*/ if(type.equals(BLACK))
/*385*/ {
/*386*/ handle = INTERFACE_HANDLE.makeBLACK_LIST();
/*387*/ if(DEBUG) System.out.println(BLACK); // デバッグ
/*388*/ }
/*389*/ else if(type.equals(WHITE))
/*390*/ {
/*391*/ handle = INTERFACE_HANDLE.makeWHITE_LIST();
/*392*/ if(DEBUG) System.out.println(WHITE); // デバッグ
/*393*/ }
/*394*/ else
/*395*/ throw new Exception("Illegal File");
/*396*/
/*397*/ // フィルタのセット
/*398*/ Object[] obj = ZipDecompresser.decompress(zipfile);
/*399*/ for(int i=0;i<obj.length;i++)
/*400*/ {
/*401*/ try
/*402*/ {
/*403*/ handle.addFilter((FILTER_DESCRIPTOR)obj[i]);
/*404*/ }
/*405*/ catch(ClassCastException cce){}
/*406*/ }
/*407*/
/*408*/ handleList.add(handle);
/*409*/ zipfile.close();
/*410*/ } // readInterfaceHandle END
インタフェースハンドル読み込みメソッドです。書き込みの逆で、zipファイルからタイプファイルを読み込み、そのハンドルを新規作成、その後オブジェク
トで保存されたフィルタを読み込み追加していきます。
ZipDecompresser.java(補助クラス)
/*123*/ public static Object[] decompress(ZipFile zipfile)
/*124*/ throws IOException, ClassNotFoundException
/*125*/ {
/*126*/ Object[] obj = new Object[zipfile.size()];
/*127*/ Enumeration e = zipfile.entries();
/*128*/
/*129*/ for(int i=0;e.hasMoreElements();i++)
/*130*/ {
/*131*/ ObjectInputStream in = null;
/*132*/ try
/*133*/ {
/*134*/ in = new ObjectInputStream(zipfile.getInputStream(
/*135*/ (ZipEntry)e.nextElement()));
/*136*/ obj[i] = in.readObject();
/*137*/ }
/*138*/ finally
/*139*/ {
/*140*/ if(in!=null) in.close();
/*141*/ }
/*142*/ }
/*143*/
/*144*/ return obj;
/*145*/ }
/*146*/ }
ハンドルファイル読み込み時に使うzipファイル関連メソッドです。対象のzipファイル内の全てのオブジェクトを得られます。
/*412*/ // ハンドルファイルのタイプを得る
/*413*/ public String getHandleFileType(ZipFile zipfile)
/*414*/ throws IOException, ClassNotFoundException
/*415*/ {
/*416*/ return (String)ZipDecompresser.decompress(
/*417*/ zipfile, new ZipEntry(typefile));
/*418*/ } // getHandleFileType END
/*419*/
/*420*/ // インタフェースハンドルファイルを削除する
/*421*/ public static void deleteHandle(String path) throws Exception
/*422*/ {
/*423*/ new File(path).delete();
/*424*/ } // deleteFolder END
/*425*/
/*426*/ // インタフェースハンドルファイル一覧を検索する
/*427*/ public static String[] searchHandle(String path)
/*428*/ {
/*429*/ File f = new File(path);
/*430*/
/*431*/ return f.list(new FilenameFilter(){
/*432*/ public boolean accept(File dir, String name)
/*433*/ {
/*434*/ if(name.toLowerCase().endsWith(hExtension) )
/*435*/ return true;
/*436*/ else
/*437*/ return false;
/*438*/ }
/*439*/ });
/*440*/ } // searchHandle END
/*441*/
/*442*/ // ハンドルファイルが存在するか
/*443*/ public static boolean existHandle(String filename)
/*444*/ {
/*445*/ return new File(filename+hExtension).exists();
/*446*/ } // existHandle END
/*447*/
/*448*/ // インタフェースハンドルをString形式にする
/*449*/ public static String toStringHandle(INTERFACE_HANDLE handle)
/*450*/ {
/*451*/ String s;
/*452*/
/*453*/ if(handle.rule==INTERFACE_HANDLE.BLACK_LIST)
/*454*/ s="BLACK LIST ";
/*455*/ else
/*456*/ s="WHITE LIST ";
/*457*/
/*458*/ return s+handle.getSize();
/*459*/ } // toStringHandle END
/*460*/
/*461*/ // ハンドル内のフィルタをString形式にする
/*462*/ public String[] toStringFiltersInHandle(int index)
/*463*/ {
/*464*/ INTERFACE_HANDLE handle = (INTERFACE_HANDLE)(handleList.get(index));
/*465*/
/*466*/ String[] s = new String[handle.getSize()];
/*467*/
/*468*/ for(int i=0;i<handle.getSize();i++)
/*469*/ {
/*470*/ s[i] = toStringFilter(handle.getFilter(i));
/*471*/ }
/*472*/
/*473*/ return s;
/*474*/ } // toStringFiltersInHandle END
/*475*/
/*476*/ // リストの対象のインタフェースハンドルのString形式を得る
/*477*/ public String getHandleString(int index)
/*478*/ {
/*479*/ return toStringHandle((INTERFACE_HANDLE)(handleList.get(index)));
/*480*/ } // getHandleString END
これらはハンドルファイル関連のメソッドです。
427〜440行目はハンドル検索メソッドです。検索にはFilenameFilterを無名クラスで利用しています。
449〜459行目はハンドルを識別する為にString形式に変換します。ハンドルは"ハンドルタイプ ハンドル数"で表しています。
/*484*/ // リストにフィルタを追加する
/*485*/ private void addFilter(FILTER_DESCRIPTOR filter)
/*486*/ {
/*487*/ filterList.add(filter);
/*488*/ } // addFilter END
/*489*/
/*490*/ // リストにIPフィルタを追加する
/*491*/ public void addIPfilter(InetAddress Sadrs, InetAddress Smsk,
/*492*/ InetAddress Dadrs, InetAddress Dmsk)
/*493*/ {
/*494*/ InetAddress[] forCheck = {Sadrs,Smsk,Dadrs,Dmsk};
/*495*/
/*496*/ FILTER_DESCRIPTOR filter = PacketFiltering.getIPfilter();
/*497*/ filter.SrcAddr = Sadrs;
/*498*/ filter.SrcMask = Smsk;
/*499*/ filter.DstAddr = Dadrs;
/*500*/ filter.DstMask = Dmsk;
/*501*/
/*502*/ if(isV4(forCheck))
/*503*/ filter.AddrType = PacketFiltering.IPv4_FLAG;
/*504*/ else if(isV6(forCheck))
/*505*/ filter.AddrType = PacketFiltering.IPv6_FLAG;
/*506*/ else
/*507*/ throw new IllegalArgumentException("Illegal IPaddress");
/*508*/
/*509*/ addFilter(filter);
/*510*/ } // addIPfilter END
/*511*/
/*512*/ // リストにICMPフィルタを追加する
/*513*/ public void addICMPfilter(InetAddress Sadrs, InetAddress Smsk,
/*514*/ InetAddress Dadrs, InetAddress Dmsk)
/*515*/ {
/*516*/ InetAddress[] forCheck = {Sadrs,Smsk,Dadrs,Dmsk};
/*517*/
/*518*/ FILTER_DESCRIPTOR filter = PacketFiltering.getICMPfilter();
/*519*/ filter.SrcAddr = Sadrs;
/*520*/ filter.SrcMask = Smsk;
/*521*/ filter.DstAddr = Dadrs;
/*522*/ filter.DstMask = Dmsk;
/*523*/
/*524*/ if(isV4(forCheck))
/*525*/ filter.AddrType = PacketFiltering.IPv4_FLAG;
/*526*/ else if(isV6(forCheck))
/*527*/ filter.AddrType = PacketFiltering.IPv6_FLAG;
/*528*/ else
/*529*/ throw new IllegalArgumentException("Illegal IPaddress");
/*530*/
/*531*/ addFilter(filter);
/*532*/ } // addICMPfilter END
/*533*/
/*534*/ // リストにTCPフィルタを追加する
/*535*/ public void addTCPfilter(InetAddress Sadrs, InetAddress Smsk,
/*536*/ InetAddress Dadrs, InetAddress Dmsk,
/*537*/ int sPort, int dPort, int csPort, int cdPort)
/*538*/ {
/*539*/ InetAddress[] forCheck = {Sadrs,Smsk,Dadrs,Dmsk};
/*540*/
/*541*/ FILTER_DESCRIPTOR filter = PacketFiltering.getTCPfilter();
/*542*/ filter.SrcAddr = Sadrs;
/*543*/ filter.SrcMask = Smsk;
/*544*/ filter.DstAddr = Dadrs;
/*545*/ filter.DstMask = Dmsk;
/*546*/
/*547*/ if(isV4(forCheck))
/*548*/ filter.AddrType = PacketFiltering.IPv4_FLAG;
/*549*/ else if(isV6(forCheck))
/*550*/ filter.AddrType = PacketFiltering.IPv6_FLAG;
/*551*/ else
/*552*/ throw new IllegalArgumentException("Illegal IPaddress");
/*553*/
/*554*/ filter.SrcPort = sPort;
/*555*/ filter.DstPort = dPort;
/*556*/ filter.CeilingSrcPort = csPort;
/*557*/ filter.CeilingDstPort = cdPort;
/*558*/
/*559*/ addFilter(filter);
/*560*/ } // addTCPfilter END
/*561*/
/*562*/ // リストにUDPフィルタを追加する
/*563*/ public void addUDPfilter(InetAddress Sadrs, InetAddress Smsk,
/*564*/ InetAddress Dadrs, InetAddress Dmsk,
/*565*/ int sPort, int dPort, int csPort, int cdPort)
/*566*/ {
/*567*/ InetAddress[] forCheck = {Sadrs,Smsk,Dadrs,Dmsk};
/*568*/
/*569*/ FILTER_DESCRIPTOR filter = PacketFiltering.getUDPfilter();
/*570*/ filter.SrcAddr = Sadrs;
/*571*/ filter.SrcMask = Smsk;
/*572*/ filter.DstAddr = Dadrs;
/*573*/ filter.DstMask = Dmsk;
/*574*/
/*575*/ if(isV4(forCheck))
/*576*/ filter.AddrType = PacketFiltering.IPv4_FLAG;
/*577*/ else if(isV6(forCheck))
/*578*/ filter.AddrType = PacketFiltering.IPv6_FLAG;
/*579*/ else
/*580*/ throw new IllegalArgumentException("Illegal IPaddress");
/*581*/
/*582*/ filter.SrcPort = sPort;
/*583*/ filter.DstPort = dPort;
/*584*/ filter.CeilingSrcPort = csPort;
/*585*/ filter.CeilingDstPort = cdPort;
/*586*/
/*587*/ addFilter(filter);
/*588*/ } // addUDPfilter END
フィルタを新規作成するメソッドです。各フィルタの種類に合わせて引数を与え、その情報のフィルタを作成します。
502〜507行目は引数のIPアドレスが全てIPv4もしくはIPv6かどうか判定しています。どちらでもない場合は例外を発生させます。
/*590*/ // リストからフィルタを取り除く
/*591*/ public void removeFilter(int index)
/*592*/ {
/*593*/ filterList.remove(index);
/*594*/ } // removeFilter END
/*595*/
/*596*/ // フィルタリストをクリアする
/*597*/ public void clearFilter()
/*598*/ {
/*599*/ filterList.clear();
/*600*/ } // clearFilter END
/*601*/
/*602*/ // リストのフィルタ数を得る
/*603*/ public int getFilterNum()
/*604*/ {
/*605*/ return filterList.size();
これらはフィルタ関連のメソッドです。
/*608*/ // リストのIPフィルタを編集する
/*609*/ public void editIPFilter(int index, InetAddress Sadrs,
/*610*/ InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk)
/*611*/ {
/*612*/ FILTER_DESCRIPTOR nowfilter = (FILTER_DESCRIPTOR)(filterList.get(index));
/*613*/
/*614*/ FILTER_DESCRIPTOR newfilter = PacketFiltering.getIPfilter();
/*615*/ if(Sadrs == null) newfilter.SrcAddr = nowfilter.SrcAddr;
/*616*/ else newfilter.SrcAddr = Sadrs;
/*617*/
/*618*/ if(Smsk == null) newfilter.SrcMask = nowfilter.SrcMask;
/*619*/ else newfilter.SrcMask = Smsk;
/*620*/
/*621*/ if(Dadrs == null) newfilter.DstAddr = nowfilter.DstAddr;
/*622*/ else newfilter.DstAddr = Dadrs;
/*623*/
/*624*/ if(Dmsk == null) newfilter.DstMask = nowfilter.DstMask;
/*625*/ else newfilter.DstMask = Dmsk;
/*626*/
/*627*/ InetAddress[] forCheck = {newfilter.SrcAddr,newfilter.SrcMask,
/*628*/ newfilter.DstAddr,newfilter.DstMask};
/*629*/
/*630*/ if(isV4(forCheck))
/*631*/ newfilter.AddrType = PacketFiltering.IPv4_FLAG;
/*632*/ else if(isV6(forCheck))
/*633*/ newfilter.AddrType = PacketFiltering.IPv6_FLAG;
/*634*/ else
/*635*/ throw new IllegalArgumentException("Illegal IPaddress");
/*636*/
/*637*/ filterList.set(index, newfilter);
/*638*/ } // editIPFilter END
フィルタ編集メソッドです。フィルタ作成メソッドと同様で、フィルタ情報に必要な引数を与えますが、要素が空の場合は変更されません。ICMP、TCP、
UDPフィルタも同様のことをします。
/*770*/ // フィルタを書き込み
/*771*/ public void writeFilterDescriptor(String filename, int index)
/*772*/ throws IOException, FileNotFoundException
/*773*/ {
/*774*/ ObjectOutputStream out = null;
/*775*/
/*776*/ try
/*777*/ {
/*778*/ out = new ObjectOutputStream(
/*779*/ new FileOutputStream(filename+fExtension));
/*780*/
/*781*/ out.writeObject((FILTER_DESCRIPTOR)(filterList.get(index)));
/*782*/ }
/*783*/ finally
/*784*/ {
/*785*/ if(out!=null) out.close();
/*786*/ }
/*787*/ } // writeFilterDescriptor END
/*788*/
/*789*/ // フィルタを読み込み
/*790*/ public void readFilterDescriptor(String filename)
/*791*/ throws IOException, ClassNotFoundException
/*792*/ {
/*793*/ ObjectInputStream in = null;
/*794*/
/*795*/ try
/*796*/ {
/*797*/ in = new ObjectInputStream(new FileInputStream(filename));
/*798*/
/*799*/ FILTER_DESCRIPTOR filter = (FILTER_DESCRIPTOR)in.readObject();
/*800*/
/*801*/ filterList.add(filter);
/*802*/ }
/*803*/ finally
/*804*/ {
/*805*/ if(in!=null) in.close();
/*806*/ }
/*807*/ } // readFilterDescriptor END
/*808*/
/*809*/ // フィルタファイルを削除する
/*810*/ public void deleteFilter(String path)
/*811*/ {
/*812*/ new File(path).delete();
/*813*/ } // deleteFile END
/*814*/
/*815*/ // フィルタファイル一覧を検索する
/*816*/ public static String[] searchFilter(String path)
/*817*/ {
/*818*/ File f = new File(path);
/*819*/
/*820*/ return f.list(new FilenameFilter(){
/*821*/ public boolean accept(File dir, String name)
/*822*/ {
/*823*/ if(name.toLowerCase().endsWith(fExtension) )
/*824*/ return true;
/*825*/ else
/*826*/ return false;
/*827*/ }
/*828*/ });
/*829*/ } // searchFilter END
/*830*/
/*831*/ // フィルタファイルが存在するか
/*832*/ public static boolean existFilter(String filename)
/*833*/ {
/*834*/ return new File(filename+fExtension).exists();
/*835*/ } // existFilter END
これらはフィルタファイル関連のメソッドです。フィルタはオブジェクトのままで保存されます。
/*837*/ // フィルタをString形式にする
/*838*/ public static String toStringFilter(FILTER_DESCRIPTOR filter)
/*839*/ {
/*840*/ StringBuffer s = new StringBuffer();
/*841*/
/*842*/ s.append(filter.SrcAddr.getHostAddress());
/*843*/ s.append("/");
/*844*/ s.append(filter.SrcMask.getHostAddress());
/*845*/ s.append("->");
/*846*/ s.append(filter.DstAddr.getHostAddress());
/*847*/ s.append("/");
/*848*/ s.append(filter.DstMask.getHostAddress());
/*849*/ s.append("&");
/*850*/
/*851*/ if(filter.Protocol==PacketFiltering.ANY_PROTOCOL)
/*852*/ s.append("ANY PROTOCOL=");
/*853*/ else if(filter.Protocol==PacketFiltering.ICMP)
/*854*/ s.append("ICMP=");
/*855*/ else if(filter.Protocol==PacketFiltering.TCP)
/*856*/ s.append("TCP=");
/*857*/ else if(filter.Protocol==PacketFiltering.UDP)
/*858*/ s.append("UDP=");
/*859*/
/*860*/
/*861*/ s.append(filter.SrcPort);
/*862*/ s.append("^");
/*863*/ s.append(filter.CeilingSrcPort);
/*864*/ s.append("->");
/*865*/ s.append(filter.DstPort);
/*866*/ s.append("^");
/*867*/ s.append(filter.CeilingDstPort);
/*868*/
/*869*/ return s.toString();
/*870*/ } // toStringFilter END
/*871*/
/*872*/ // リストの対象のフィルタのString形式を得る
/*873*/ public String getFilterString(int index)
/*874*/ {
/*875*/ return toStringFilter((FILTER_DESCRIPTOR)(filterList.get(index)));
/*876*/ } // getFilterString END
/*877*/
/*878*/ // リストのフィルタのプロトコルを得る
/*879*/ public int getFilterProtocol(int index)
/*880*/ {
/*881*/ return ((FILTER_DESCRIPTOR)(filterList.get(index))).Protocol;
/*882*/ } // getFilterProtocol END
これらはフィルタを識別する為にString形式にするメソッドです。フィルタは"送信元IPアドレス/送信元マスク->送信先IPアドレ
ス/送信先マスク&フィルタタイプ=送信元ポート番号^送信元ポート番号上限->送信先ポート番号^送信先ポート番号上限
"で表しています。
メニューに戻る
