/* 1*/ /*********************************************************************************
/* 2*/ *
/* 3*/ * PFSaver クラス
/* 4*/ *
/* 5*/ * パケットフィルタリングアプリケーションの支援メソッド群
/* 6*/ *
/* 7*/ *
/* 8*/ * WinPacketFilteringパッケージを使用する
/* 9*/ * フィルタ、ハンドルの保存、読み込み、編集、削除
/* 10*/ * IP、ICMP、TCP、UDPフィルタを作成可
/* 11*/ *
/* 12*/ *
/* 13*/ *
/* 14*/ * public メソッド
/* 15*/ * ・PFSaver()
/* 16*/ * コンストラクタ
/* 17*/ *
/* 18*/ * ********** フィルタリング動作関連 **********
/* 19*/ * ・void startFiltering(InetAddress adrs, int inH, int outH)
/* 20*/ * フィルタリングを開始する
/* 21*/ *
/* 22*/ * ・void stopFiltering()
/* 23*/ * フィルタリングを停止する
/* 24*/ *
/* 25*/ * ・boolean isWorking()
/* 26*/ * フィルタリンが動作中かどうか
/* 27*/ *
/* 28*/ * ********** アプリケーション補助 **********
/* 29*/ * ・void restoreList(String path)
/* 30*/ * 前回終了時リストを復元する
/* 31*/ *
/* 32*/ * ・void recordList(String path)
/* 33*/ * ハンドル・フィルタのリストを記録する
/* 34*/ *
/* 35*/ * ********** インタフェースハンドル関連 **********
/* 36*/ * ・void addBlackListHandle()
/* 37*/ * リストにブラックリスト・ハンドルを追加する
/* 38*/ *
/* 39*/ * ・void addWhiteListHandle()
/* 40*/ * リストにホワイトリスト・ハンドルを追加する
/* 41*/ *
/* 42*/ * ・void removeHandle(int index)
/* 43*/ * リストからインタフェースハンドルを取り除く
/* 44*/ *
/* 45*/ * ・void clearHandle()
/* 46*/ * インタフェースハンドルリストをクリアする
/* 47*/ *
/* 48*/ * ・int getHandleNum()
/* 49*/ * リストのハンドル数を得る
/* 50*/ *
/* 51*/ * ・void setFilterToHandle(int Hindex, int Findex)
/* 52*/ * フィルタをインタフェースハンドルにセットする
/* 53*/ *
/* 54*/ * ・void removeFilterFromHandle(int hIndex, int fIndex)
/* 55*/ * リストのハンドルからフィルタを削除する
/* 56*/ *
/* 57*/ * ・void writeInterfaceHandle(String filename, int index)
/* 58*/ * インタフェースハンドルをファイルに書き込む
/* 59*/ *
/* 60*/ * ・void readInterfaceHandle(String filename)
/* 61*/ * インタフェースハンドルファイルを読み込む
/* 62*/ *
/* 63*/ * ・String getHandleFileType(ZipFile zipfile)
/* 64*/ * ハンドルファイルのタイプを得る
/* 65*/ *
/* 66*/ * ・void deleteHandle(String path)
/* 67*/ * インタフェースハンドルファイルを削除する
/* 68*/ *
/* 69*/ * ・String[] searchHandle(String path)
/* 70*/ * インタフェースハンドルファイル一覧を検索する
/* 71*/ *
/* 72*/ * ・boolean existHandle(String filename)
/* 73*/ * ハンドルファイルが存在するか
/* 74*/ *
/* 75*/ * ・String toStringHandle(INTERFACE_HANDLE handle)
/* 76*/ * インタフェースハンドルをString形式にする
/* 77*/ *
/* 78*/ * ・String[] toStringFiltersInHandle(int index)
/* 79*/ * ハンドル内のフィルタをString形式にする
/* 80*/ *
/* 81*/ * ・String getHandleString(int index)
/* 82*/ * リストの対象のインタフェースハンドルのString形式を得る
/* 83*/ *
/* 84*/ * ********** フィルタディスクリプタ関連 **********
/* 85*/ * ・void addIPfilter(InetAddress Sadrs, InetAddress Smsk,
/* 86*/ * InetAddress Dadrs, InetAddress Dmsk)
/* 87*/ * リストにIPフィルタを追加する
/* 88*/ *
/* 89*/ * ・void addICMPfilter(InetAddress Sadrs, InetAddress Smsk,
/* 90*/ * InetAddress Dadrs, InetAddress Dmsk)
/* 91*/ * リストにICMPフィルタを追加する
/* 92*/ *
/* 93*/ * ・void addTCPfilter(InetAddress Sadrs, InetAddress Smsk,
/* 94*/ * InetAddress Dadrs, InetAddress Dmsk,
/* 95*/ * int sPort, int dPort, int csPort, int cdPort)
/* 96*/ * リストにTCPフィルタを追加する
/* 97*/ *
/* 98*/ * ・void addUDPfilter(InetAddress Sadrs, InetAddress Smsk,
/* 99*/ * InetAddress Dadrs, InetAddress Dmsk,
/*100*/ * int sPort, int dPort, int csPort, int cdPort)
/*101*/ * リストにUDPフィルタを追加する
/*102*/ *
/*103*/ * ・void removeFilter(int index)
/*104*/ * リストからフィルタを取り除く
/*105*/ *
/*106*/ * ・void clearFilter()
/*107*/ * フィルタリストをクリアする
/*108*/ *
/*109*/ * ・int getFilterNum()
/*110*/ * リストのフィルタ数を得る
/*111*/ *
/*112*/ * ・void editIPFilter(int index, InetAddress Sadrs,
/*113*/ * InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk)
/*114*/ * リストのIPフィルタを編集する
/*115*/ *
/*116*/ * ・void editICMPFilter(int index, InetAddress Sadrs,
/*117*/ * InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk)
/*118*/ * リストのICMPフィルタを編集する
/*119*/ *
/*120*/ * ・void editTCPFilter(int index, InetAddress Sadrs,
/*121*/ * InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk,
/*122*/ * int sPort, int dPort, int csPort, int cdPort)
/*123*/ * リストのTCPフィルタを編集する
/*124*/ *
/*125*/ * ・void editUDPFilter(int index, InetAddress Sadrs,
/*126*/ * InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk,
/*127*/ * int sPort, int dPort, int csPort, int cdPort)
/*128*/ * リストのUDPフィルタを編集する
/*129*/ *
/*130*/ * ・void writeFilterDescriptor(String filename, int index)
/*131*/ * フィルタを書き込み
/*132*/ *
/*133*/ * ・void readFilterDescriptor(String filename)
/*134*/ * フィルタを読み込み
/*135*/ *
/*136*/ * ・void deleteFilter(String path)
/*137*/ * フィルタファイルを削除する
/*138*/ *
/*139*/ * ・String[] searchFilter(String path)
/*140*/ * フィルタファイル一覧を検索する
/*141*/ *
/*142*/ * ・boolean existFilter(String filename)
/*143*/ * フィルタファイルが存在するか
/*144*/ *
/*145*/ * ・String toStringFilter(FILTER_DESCRIPTOR filter)
/*146*/ * フィルタをString形式にする
/*147*/ *
/*148*/ * ・String getFilterString(int index)
/*149*/ * リストの対象のフィルタのString形式を得る
/*150*/ *
/*151*/ * ・int getFilterProtocol(int index)
/*152*/ * リストのフィルタのプロトコルを得る
/*153*/ *
/*154*/ *
/*155*/ *
/*156*/ * private メソッド
/*157*/ * ・void addHandle(INTERFACE_HANDLE handle)
/*158*/ * リストにインタフェースハンドルを追加する
/*159*/ *
/*160*/ * ・void addFilter(FILTER_DESCRIPTOR filter)
/*161*/ * リストにフィルタを追加する
/*162*/ *
/*163*/ * ・boolean isV6(InetAddress[] inetadrs)
/*164*/ * 入力されたInetAddressが全てIPv6がどうか調べる
/*165*/ *
/*166*/ * ・boolean isV4(InetAddress[] inetadrs)
/*167*/ * 入力されたInetAddressが全てIPv4がどうか調べる
/*168*/ *
/*169*/ *********************************************************************************/
/*170*/
/*171*/ package PFSaver;
/*172*/
/*173*/ import java.io.File;
/*174*/ import java.io.FileInputStream;
/*175*/ import java.io.FileNotFoundException;
/*176*/ import java.io.FileOutputStream;
/*177*/ import java.io.FilenameFilter;
/*178*/ import java.io.IOException;
/*179*/ import java.io.ObjectInputStream;
/*180*/ import java.io.ObjectOutputStream;
/*181*/ import java.net.Inet4Address;
/*182*/ import java.net.Inet6Address;
/*183*/ import java.net.InetAddress;
/*184*/ import java.util.ArrayList;
/*185*/ import java.util.zip.ZipEntry;
/*186*/ import java.util.zip.ZipFile;
/*187*/
/*188*/ import WinPacketFiltering.*;
/*189*/
/*190*/ public class PFSaver
/*191*/ {
/*192*/ private static final boolean DEBUG = false;
/*193*/
/*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; // フィルタリングが動作中かどうか
/*202*/
/*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
/*241*/
/*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
/*296*/
/*297*/
/*298*/
/*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
/*347*/
/*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
/*373*/
/*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
/*411*/
/*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
/*481*/
/*482*/
/*483*/
/*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
/*589*/
/*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();
/*606*/ } // getFilterNum END
/*607*/
/*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
/*639*/
/*640*/ // リストのICMPフィルタを編集する
/*641*/ public void editICMPFilter(int index, InetAddress Sadrs,
/*642*/ InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk)
/*643*/ {
/*644*/ FILTER_DESCRIPTOR nowfilter = (FILTER_DESCRIPTOR)(filterList.get(index));
/*645*/
/*646*/ FILTER_DESCRIPTOR newfilter = PacketFiltering.getICMPfilter();
/*647*/ if(Sadrs == null) newfilter.SrcAddr = nowfilter.SrcAddr;
/*648*/ else newfilter.SrcAddr = Sadrs;
/*649*/
/*650*/ if(Smsk == null) newfilter.SrcMask = nowfilter.SrcMask;
/*651*/ else newfilter.SrcMask = Smsk;
/*652*/
/*653*/ if(Dadrs == null) newfilter.DstAddr = nowfilter.DstAddr;
/*654*/ else newfilter.DstAddr = Dadrs;
/*655*/
/*656*/ if(Dmsk == null) newfilter.DstMask = nowfilter.DstMask;
/*657*/ else newfilter.DstMask = Dmsk;
/*658*/
/*659*/ InetAddress[] forCheck = {newfilter.SrcAddr,newfilter.SrcMask,
/*660*/ newfilter.DstAddr,newfilter.DstMask};
/*661*/
/*662*/ if(isV4(forCheck))
/*663*/ newfilter.AddrType = PacketFiltering.IPv4_FLAG;
/*664*/ else if(isV6(forCheck))
/*665*/ newfilter.AddrType = PacketFiltering.IPv6_FLAG;
/*666*/ else
/*667*/ throw new IllegalArgumentException("Illegal IPaddress");
/*668*/
/*669*/ filterList.set(index, newfilter);
/*670*/ } // editICMPFilter END
/*671*/
/*672*/ // リストのTCPフィルタを編集する
/*673*/ public void editTCPFilter(int index, InetAddress Sadrs,
/*674*/ InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk,
/*675*/ int sPort, int dPort, int csPort, int cdPort)
/*676*/ {
/*677*/ FILTER_DESCRIPTOR nowfilter = (FILTER_DESCRIPTOR)(filterList.get(index));
/*678*/
/*679*/ FILTER_DESCRIPTOR newfilter = PacketFiltering.getTCPfilter();
/*680*/ if(Sadrs == null) newfilter.SrcAddr = nowfilter.SrcAddr;
/*681*/ else newfilter.SrcAddr = Sadrs;
/*682*/
/*683*/ if(Smsk == null) newfilter.SrcMask = nowfilter.SrcMask;
/*684*/ else newfilter.SrcMask = Smsk;
/*685*/
/*686*/ if(Dadrs == null) newfilter.DstAddr = nowfilter.DstAddr;
/*687*/ else newfilter.DstAddr = Dadrs;
/*688*/
/*689*/ if(Dmsk == null) newfilter.DstMask = nowfilter.DstMask;
/*690*/ else newfilter.DstMask = Dmsk;
/*691*/
/*692*/ InetAddress[] forCheck = {newfilter.SrcAddr,newfilter.SrcMask,
/*693*/ newfilter.DstAddr,newfilter.DstMask};
/*694*/
/*695*/ if(isV4(forCheck))
/*696*/ newfilter.AddrType = PacketFiltering.IPv4_FLAG;
/*697*/ else if(isV6(forCheck))
/*698*/ newfilter.AddrType = PacketFiltering.IPv6_FLAG;
/*699*/ else
/*700*/ throw new IllegalArgumentException("Illegal IPaddress");
/*701*/
/*702*/ if(sPort == PacketFiltering.NO_SET) newfilter.SrcPort = nowfilter.SrcPort;
/*703*/ else newfilter.SrcPort = sPort;
/*704*/
/*705*/ if(dPort == PacketFiltering.NO_SET) newfilter.DstPort = nowfilter.DstPort;
/*706*/ else newfilter.DstPort = dPort;
/*707*/
/*708*/ if(csPort == PacketFiltering.NO_SET)
/*709*/ newfilter.CeilingSrcPort = nowfilter.CeilingSrcPort;
/*710*/ else
/*711*/ newfilter.CeilingSrcPort = csPort;
/*712*/
/*713*/ if(cdPort == PacketFiltering.NO_SET)
/*714*/ newfilter.CeilingDstPort = nowfilter.CeilingDstPort;
/*715*/ else
/*716*/ newfilter.CeilingDstPort = cdPort;
/*717*/
/*718*/ filterList.set(index, newfilter);
/*719*/ } // editTCPFilter END
/*720*/
/*721*/ // リストのUDPフィルタを編集する
/*722*/ public void editUDPFilter(int index, InetAddress Sadrs,
/*723*/ InetAddress Smsk, InetAddress Dadrs, InetAddress Dmsk,
/*724*/ int sPort, int dPort, int csPort, int cdPort)
/*725*/ {
/*726*/ FILTER_DESCRIPTOR nowfilter = (FILTER_DESCRIPTOR)(filterList.get(index));
/*727*/
/*728*/ FILTER_DESCRIPTOR newfilter = PacketFiltering.getUDPfilter();
/*729*/ if(Sadrs == null) newfilter.SrcAddr = nowfilter.SrcAddr;
/*730*/ else newfilter.SrcAddr = Sadrs;
/*731*/
/*732*/ if(Smsk == null) newfilter.SrcMask = nowfilter.SrcMask;
/*733*/ else newfilter.SrcMask = Smsk;
/*734*/
/*735*/ if(Dadrs == null) newfilter.DstAddr = nowfilter.DstAddr;
/*736*/ else newfilter.DstAddr = Dadrs;
/*737*/
/*738*/ if(Dmsk == null) newfilter.DstMask = nowfilter.DstMask;
/*739*/ else newfilter.DstMask = Dmsk;
/*740*/
/*741*/ InetAddress[] forCheck = {newfilter.SrcAddr,newfilter.SrcMask,
/*742*/ newfilter.DstAddr,newfilter.DstMask};
/*743*/
/*744*/ if(isV4(forCheck))
/*745*/ newfilter.AddrType = PacketFiltering.IPv4_FLAG;
/*746*/ else if(isV6(forCheck))
/*747*/ newfilter.AddrType = PacketFiltering.IPv6_FLAG;
/*748*/ else
/*749*/ throw new IllegalArgumentException("Illegal IPaddress");
/*750*/
/*751*/ if(sPort == PacketFiltering.NO_SET) newfilter.SrcPort = nowfilter.SrcPort;
/*752*/ else newfilter.SrcPort = sPort;
/*753*/
/*754*/ if(dPort == PacketFiltering.NO_SET) newfilter.DstPort = nowfilter.DstPort;
/*755*/ else newfilter.DstPort = dPort;
/*756*/
/*757*/ if(csPort == PacketFiltering.NO_SET)
/*758*/ newfilter.CeilingSrcPort = nowfilter.CeilingSrcPort;
/*759*/ else
/*760*/ newfilter.CeilingSrcPort = csPort;
/*761*/
/*762*/ if(cdPort == PacketFiltering.NO_SET)
/*763*/ newfilter.CeilingDstPort = nowfilter.CeilingDstPort;
/*764*/ else
/*765*/ newfilter.CeilingDstPort = cdPort;
/*766*/
/*767*/ filterList.set(index, newfilter);
/*768*/ } // editUDPFilter END
/*769*/
/*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
/*836*/
/*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
/*883*/
/*884*/ // 入力されたInetAddressが全てIPv6がどうか調べる
/*885*/ private boolean isV6(InetAddress[] inetadrs)
/*886*/ {
/*887*/ try
/*888*/ {
/*889*/ Inet6Address adrsv6;
/*890*/ for(int i=0;i<inetadrs.length;i++)
/*891*/ {
/*892*/ adrsv6 = (Inet6Address)inetadrs[i];
/*893*/ }
/*894*/ }
/*895*/ catch(ClassCastException cce)
/*896*/ {
/*897*/ return false;
/*898*/ }
/*899*/
/*900*/ return true;
/*901*/ } // isV6 END
/*902*/
/*903*/ // 入力されたInetAddressが全てIPv4がどうか調べる
/*904*/ private boolean isV4(InetAddress[] inetadrs)
/*905*/ {
/*906*/ try
/*907*/ {
/*908*/ Inet4Address adrsv4;
/*909*/ for(int i=0;i<inetadrs.length;i++)
/*910*/ {
/*911*/ adrsv4 = (Inet4Address)inetadrs[i];
/*912*/ }
/*913*/ }
/*914*/ catch(ClassCastException cce)
/*915*/ {
/*916*/ return false;
/*917*/ }
/*918*/
/*919*/ return true;
/*920*/ } // isV4 END
/*921*/ }
