home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / TemaCD / smartcache / src / mgr.java < prev    next >
Encoding:
Java Source  |  2001-01-26  |  66.8 KB  |  1,829 lines
  1. /*
  2.  *  Smart Cache, http proxy cache server
  3.  *  Copyright (C) 1998, 1999 Radim Kolar 
  4.  *
  5.  *    Smart Cache is Open Source Software; you may redistribute it
  6.  *  and/or modify it under the terms of the GNU General Public
  7.  *  License as published by the Free Software Foundation; either
  8.  *  version 2, or (at your option) any later version.
  9.  *
  10.  *    This program distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13.  *  General Public License for more details.
  14.  *
  15.  *    A copy of the GNU General Public License is available as
  16.  *  /usr/doc/copyright/GPL in the Debian GNU/Linux distribution or on
  17.  *  the World Wide Web at http://www.gnu.org/copyleft/gpl.html. You
  18.  *  can also obtain it by writing to the Free Software Foundation,
  19.  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  */
  21.  
  22. import java.io.*;
  23. import java.util.*;
  24. import java.text.*;
  25. import java.util.zip.*;
  26. import java.net.*;
  27.  
  28. public final class mgr implements Runnable{
  29.  
  30. public static final String DEFAULTNAME=".welcome";
  31. /* cache manager */
  32. public static InetAddress parentproxy;
  33. public static String parentauth; /* auth header */
  34. public static int port; // parentproxyport
  35.  
  36. public static int ourport;
  37. private static InetAddress ouraddress;
  38.  
  39. private static final long SAVETIMER=1000L*60*3; /* 3 min. */
  40. public  static String cache_dir;
  41. private static String custom403;
  42. public static int swap_level1_dirs= 4;
  43. public static int swap_level2_dirs= 4;
  44. public  static String[] no_proxy;
  45. public  static String[] allow_cookies_to;
  46. public static boolean case_sensitive;
  47.  
  48. /* ad Busters */
  49. private  static AdBuster ad;
  50. private  static String AdID,AdAuth;
  51.  
  52. /* access rulez */
  53. private  static  boolean cacheonly;
  54. private  static  regexp[] fail;
  55. private  static  regexp[] nocache;
  56. private  static  regexp[] pass;
  57. private  static  int allowconnect[];
  58. private  static  boolean fail_trace;
  59.  
  60. /* time stamps */
  61. private  static  long pass_timestamp;
  62. private  static  long fail_timestamp;
  63. private  static  long cookie_timestamp;
  64.  
  65. private  static  String cookie_filename;
  66. private  static  String pass_filename;
  67. private  static  String fail_filename;
  68.  
  69. /* refresh strategy - multiple */
  70. private  static regexp[] refresh;
  71. private  static long minage[];
  72. private  static long maxage[];
  73. private  static long reloadage[];
  74. private  static float lastmodf[];
  75. private  static long expireage[];
  76. private  static long redirage[];
  77.  
  78. /* simple refresh p. */
  79. private  static long min_age;
  80. public   static long max_age;
  81. private  static long reload_age;
  82. private  static long expire_age;
  83. private  static long redir_age;
  84. private  static float lmfactor;
  85.  
  86. /* redirects */
  87. private  static String[] redirfrom;
  88. private  static String[] redirto;
  89.  
  90. private  static Hashtable dircache;
  91.  
  92. /* flags */
  93. private  static String shutdownflag,immediate_shutdownflag;
  94. public static boolean clear_flags_on_start=true;
  95. private static int flag_check_interval;
  96.  
  97. /* log for statistic */
  98. private static String stat_log;
  99.  
  100. mgr()
  101. {
  102.  dircache=new Hashtable(25);
  103.  /* init to some defaults */
  104.  /* static intit */
  105.  request.formatter.setTimeZone(TimeZone.getTimeZone("GMT")); 
  106.  httpreq.formatter.setTimeZone(TimeZone.getDefault());
  107.  /* compute timezone in apache log style format */
  108.  int ofs=TimeZone.getDefault().getRawOffset();
  109.  if(TimeZone.getDefault().inDaylightTime(new Date())) ofs+=60*60*1000;
  110.  httpreq.timezone=(ofs<0?" -":" +");
  111.  ofs=Math.abs(ofs);
  112.  httpreq.timezone=httpreq.timezone+
  113.             (ofs/(60*60*1000)<10 ? "0"+ofs/(60*60*1000): ""+ofs/(60*60*1000));
  114. ofs-=(ofs/(60*60*1000))*60*60*1000;
  115. ofs/=60*1000;
  116. httpreq.timezone=httpreq.timezone+(ofs<10? "0"+ofs : ""+ofs)+"] \"";
  117.  
  118.  /* defaults */
  119.  cacheonly=false;
  120.  cache_dir="store";
  121.  port=3128; /* default squid parent proxy port */
  122.  ourport=8080; /* well known webcache port     */
  123.  request.default_forward_for="127.0.0.1";
  124.  swap_level1_dirs= swap_level2_dirs=4;
  125.  lmfactor=0.2f;
  126.  min_age=15*60*1000L; /* 15 minut */
  127.  max_age=4*24*60*60*1000L; /* 4 dny */
  128.  expire_age=1000L*60*5; /* 5 minutes */
  129.  redir_age=15*1000L; /* 15 seconds */
  130.  request.qa_minlen=-1; /* quick abort disable */
  131.  request.qa_maxtime=3*60*60*1000L; /* max luxovaci cas 3 minuty */
  132.  httpreq.client_timeout=30*1000; /* 30 sec. read from cl. timeout */
  133.  request.read_timeout=5*60*1000; /* 5 min. read from net timeout  */
  134.  cacheobject.keep_deleted=false;
  135.  cacheobject.generate_lastmod=0;
  136.  cacheobject.hide_errors=false;
  137.  cacheobject.defaultname=DEFAULTNAME; // UGLY CERN standard
  138.  request.remove_pragma_no_cache=false;
  139.  request.referer_hack=0; 
  140.  request.fake_referer=null;
  141.  request.fake_user_agent=null;
  142.  request.append_via=true;
  143.  request.full_referer_log=true;
  144.  request.cache_protected=false; 
  145.  case_sensitive=false;
  146.  httpreq.visible_hostname="smart.cache.lan";
  147.  httpreq.visible_link=null;
  148.  cachedir.readonly=false;
  149.  clear_flags_on_start=true;
  150.  fail_trace=false;
  151.  stat_log=null;
  152.  flag_check_interval=45;
  153.  cacheobject.auto_compress=false;
  154.  cacheobject.auto_decompress=false;
  155.  
  156.  /* for safety */
  157.  cacheobject.end_dot=false;
  158.  cacheobject.escape_backslash=true;
  159. }
  160.  
  161. public final void check_filesystem()
  162. {
  163.  System.err.println("Checking filesystem ("+cache_dir+")");
  164.   
  165.  if(!cachedir.readonly)
  166.    cacheobject.end_dot=endDotFilesystem();
  167.  if(!new File(cache_dir).isDirectory())
  168.    {
  169.      System.out.println("[SMARTCACHE] Fatal Error: Directory "+cache_dir+" can not be created.");
  170.      return;
  171.    }
  172.    
  173.  if(cachedir.readonly)
  174.     System.err.println("   Using cache directory in READ-ONLY mode.");
  175.   else
  176.  {
  177.    System.err.println("   Host OS allows ending dot in filename: "+cacheobject.end_dot);
  178.    cacheobject.escape_backslash=!(filesystemCanUseBackslash());
  179.    System.err.println("   Host OS allows backslash in filename : "+!(cacheobject.escape_backslash));
  180.    garbage.realdirsize=filesystemHasRealDirsize();
  181.    System.err.println("   Host OS reports real directory size  : "+garbage.realdirsize);
  182.  
  183.  }
  184.  System.err.println("");
  185. }
  186.  
  187. public void go() throws IOException
  188. {
  189.  
  190.  scache daemon=new scache(ourport,ouraddress);
  191.  new Thread(this).start(); /* start background directory saver... */ 
  192.  
  193.  // TODO: REMOVE ALL ADBUSTERS CODE ??
  194.  scache.faststart=true; 
  195.   // NO BUSTERS AND LASTVERCHECK.  NO SERVER FOR HOSTING :(
  196.   // SOME1 WANTS TO HOST IT?
  197.   
  198.  if(scache.faststart==false)
  199.  {
  200.    System.err.println("Checking for latest Smart Cache version");
  201.    String lv=getLatestVersion();
  202.  if (lv==null) lv="(Error connecting to server)";
  203.  else if (!lv.equals(scache.CACHEVER)) lv+="\007 ... its time for update!";
  204.    else
  205.     lv+=" ... up to date";
  206.  System.err.println("   Latest version is "+lv);
  207.  }
  208.  initAdBusters();
  209.  
  210.  /* refresh pattern hack */
  211.  if(refresh!=null && !isInRegexpArray("*",refresh)) 
  212.  {
  213.   refresh=addRegexpToArray("*",refresh);
  214.                       
  215.   /* natahnout ! */
  216.   reloadage=incLongArraySize(reloadage);
  217.   minage=incLongArraySize(minage);
  218.   maxage=incLongArraySize(maxage);
  219.   lastmodf=incFloatArraySize(lastmodf);
  220.   expireage=incLongArraySize(expireage);
  221.   redirage=incLongArraySize(redirage);
  222.                     
  223.   /* nastavit hodnoty */
  224.   reloadage[reloadage.length-1]=reload_age;
  225.   minage[minage.length-1]=min_age;
  226.   maxage[maxage.length-1]=max_age;
  227.   lastmodf[lastmodf.length-1]=lmfactor;
  228.   expireage[expireage.length-1]=expire_age;
  229.   redirage[redirage.length-1]=redir_age;
  230.  }
  231.  
  232.  System.out.println(new Date()+" "+scache.VERSION+" ready."); 
  233.  // on port "+ourport+"/"+(ouraddress==null ? "*" : ouraddress.getHostAddress())+".");
  234.  
  235.  ouraddress=null; // GC IT!
  236.  httpreq.mgr=this;  
  237.  if(clear_flags_on_start)
  238.  {
  239.  checkFlag(shutdownflag); // delete pending shutdown flag on start
  240.  checkFlag(immediate_shutdownflag); // delete pending shutdown flag on start
  241.  }
  242.  daemon.httpdloop(); // enter main loop
  243. }
  244.  
  245. private final static boolean filesystemCanUseBackslash()
  246. {
  247.  if(cachedir.readonly) return false;
  248.  File test=new File(cache_dir,"test\\slash");
  249.  try{
  250.  new FileOutputStream(test).close();
  251.  }
  252.  catch (IOException e1) {
  253.                           return false;
  254.             }
  255.  
  256.  test.delete();
  257.  return true;
  258. }
  259. private final static boolean filesystemHasRealDirsize()
  260. {
  261.   try
  262.    {
  263.     if(new File(".").length()>0) return true;
  264.     else return false;
  265.   }
  266.   catch (Exception grrrrrrrrrrrrrrrr)
  267.     {
  268.       return false;
  269.     }
  270.    // return false; /* Uncomment to keep some stupid JAVAC compilers happy */
  271. }   
  272.  
  273. private final static String getLatestVersion()
  274. {
  275.  URL u=null;
  276.  try
  277.  {
  278.       u=new URL("http://adbusters.netmag.cz:8001/cachever");
  279.    // u=new URL("http://localhost:8001/cachever");
  280.  }
  281.  catch (MalformedURLException e)
  282.   { return null;}
  283.  String ver=null;
  284.  try
  285.  {
  286.    ver=new DataInputStream(u.openStream()).readLine();
  287.    return ver;
  288.  }
  289.  catch (IOException e)
  290.   { return null;}
  291.  
  292. }
  293.  
  294. private final void initAdBusters()
  295. {
  296.  if(AdID==null || AdAuth==null) return;
  297.  System.err.println("Initializing cache in AdBusters mode");
  298.  try
  299.  {
  300.    URL u;
  301.    if(scache.faststart==true)
  302.    u=new URL("http://127.0.0.1:8001/AdBuster?id="+AdID+"&auth="+AdAuth+"&e");  
  303.      else
  304.   u=new URL("http://adbusters.netmag.cz:8001/AdBuster?id="+AdID+"&auth="+AdAuth+"&e");
  305.   
  306. // u=new URL("http://localhost:8001/AdBuster?id="+AdID+"&auth="+AdAuth+"&e");
  307.   
  308.   ObjectInputStream ois=null; 
  309.   try{
  310.   ois =
  311.                     new ObjectInputStream(u.openStream());
  312.                     ad = (AdBuster)ois.readObject();
  313.                           
  314.                         }
  315.                         catch (Throwable e) {
  316.                                 System.err.println("   *ERR "+e);
  317.                         }
  318.                         finally
  319.                          {
  320.                              if(ois!=null) try{ois.close();}
  321.                                             catch(IOException e) {};
  322.                              ois=null;
  323.                          }
  324.  if(ad!=null) { System.err.println("   Refreshed rules list from server");
  325.                 mergeBusters(); 
  326.                 ad=null; 
  327.                 return;}
  328.  
  329.  
  330.  /* ze souboru */
  331.   try{
  332.   ois =
  333.                     new ObjectInputStream(new FileInputStream("AdBuster.ser"));
  334.                     ad = (AdBuster)ois.readObject();
  335.  
  336.                           
  337.                         }
  338.                         catch (Throwable e) {
  339.                                 System.err.println("  *ERR "+e);
  340.                         }
  341.                         finally
  342.                          {
  343.                              if(ois!=null) try{ois.close();}
  344.                                             catch(IOException e) {};
  345.                              ois=null;
  346.                          }
  347.                          
  348.  if(ad!=null) { System.err.println("   Rules list loaded from local backup copy");mergeBusters(); ad=null; return;}
  349.  }
  350.  catch (MalformedURLException e)
  351.   {}
  352. }
  353.  
  354. private final void mergeBusters()
  355. {
  356.  if(ad==null) return;
  357.  
  358.  /* save! */
  359.                          try {
  360.                                 BufferedOutputStream bos = new BufferedOutputStream
  361.                                     (new FileOutputStream("AdBuster.tmp"));
  362.                                 ObjectOutputStream oos =
  363.                                     new ObjectOutputStream(bos);
  364.                                 oos.writeObject(ad);
  365.                                 oos.close();                                
  366.                                 bos.close();
  367.                                 /* prejmenovat na .ser */
  368.                                 File f=new File("AdBuster.tmp");
  369.                                 File f2=new File("AdBuster.ser");
  370.                                 if(!f2.delete()) { System.err.println("   Delete old savefile failed.");}
  371.                                 if(false==f.renameTo(f2)) { System.err.println("   Rename to new savefile failed");}
  372.                         }
  373.                         catch (Throwable e) {
  374.                                 System.err.println("error when saving: "+e);
  375.                         }
  376.   for(int i=0;i<ad.allow.length;i++)
  377.    pass=addRegexpToArray(ad.allow[i],pass);
  378.  
  379.   for(int i=0;i<ad.fail.length;i++)
  380.    fail=addRegexpToArray(ad.fail[i],fail);
  381.       
  382.    
  383.   System.err.println("   Ad Busters mode init done.");
  384.   scache.VERSION=scache.CACHENAME+" "+scache.CACHEVER+" in Ad Busters mode";
  385.  
  386. }
  387. /*
  388. private final boolean caseSensitiveFilesystem()
  389. {
  390.  (new File(cache_dir)).mkdirs();
  391.  try{
  392.  new FileOutputStream(cache_dir+File.separator+"casecheck").close();
  393.  }
  394.  catch (IOException e1) {return false;}
  395.  boolean r=!new File(cache_dir+File.separator+"cAsEcHeCk").exists();
  396.  new File(cache_dir,"casecheck").delete();
  397.  return r;
  398. }
  399. */
  400. private final boolean endDotFilesystem()
  401. {
  402.  (new File(cache_dir)).mkdirs();
  403.  try{
  404.  new FileOutputStream(cache_dir+File.separator+"dot.").close();
  405.  }
  406.  catch (IOException e1) {
  407.                           cachedir.readonly=true;
  408.                           return false;
  409.             }
  410.  
  411.  File d=new File(cache_dir);
  412.  String names[];
  413.  names=d.list();
  414.  new File(cache_dir,"dot.").delete();
  415.  if(names==null) return false;
  416.   
  417.  for(int i=0;i<names.length;i++)
  418.   {
  419.    if(names[i].toLowerCase().equals("dot.")) return true;
  420.   }
  421.  
  422.  return false;
  423. }
  424.  
  425. public final void read_config(String cfgfile)
  426. {
  427.  try{
  428.  String line,token;
  429.  StringTokenizer st;
  430.  int lineno=0;
  431.  if(! new File(cfgfile).isAbsolute()) cfgfile=scache.cfgdir+File.separator+cfgfile;
  432.  
  433.  DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream(cfgfile))); 
  434.  while ( (line = dis.readLine()) != null)
  435.  {
  436.       lineno++;
  437.       if(line.startsWith("#")) continue;
  438.       st=new StringTokenizer(line);
  439.       if(st.hasMoreTokens()==false) continue;
  440.       token=st.nextToken();
  441.       try
  442.       {
  443.           
  444.           if(token.equalsIgnoreCase("visible_link")) {httpreq.visible_link=st.nextToken();
  445.                                   continue;
  446.                             }
  447.           if(token.equalsIgnoreCase("stat_log"))   {stat_log=st.nextToken();
  448.                                   continue;
  449.                             }
  450.           if(token.equalsIgnoreCase("visible_hostname")) {httpreq.visible_hostname=st.nextToken();
  451.                                   continue;
  452.                                                     }
  453.           if(token.equalsIgnoreCase("default_forward_for")) {request.default_forward_for=st.nextToken();
  454.                                   continue;
  455.                                                     }
  456.                                                     
  457.           if(token.equalsIgnoreCase("adbustersid")) {AdID=st.nextToken();
  458.                                   continue;
  459.                                                     }
  460.                                                     
  461.           if(token.equalsIgnoreCase("adbustersauth")) {AdAuth=st.nextToken();
  462.                                   continue;
  463.                                                     }
  464.                                                     
  465.          if(token.equalsIgnoreCase("defaultname")) {cacheobject.defaultname=st.nextToken();
  466.                                   continue;
  467.                                                     }
  468.  
  469.          if(token.equalsIgnoreCase("allow_cookies_to")) 
  470.                                                     {
  471.                                                      while(st.hasMoreTokens())
  472.                                                      {
  473.                                                       String z;
  474.                                                       z=st.nextToken().toLowerCase();
  475.                                                       if(z.equals("all")) { allow_cookies_to=null;break;}
  476.                                                       allow_cookies_to=addStringToArray(z,allow_cookies_to);
  477.                                                      }
  478.                                    continue;
  479.                                                     }
  480.                                                                                                         
  481.  
  482.           if(token.equalsIgnoreCase("bindaddress")) {
  483.                                                     String ip=st.nextToken();
  484.                                                     if(ip.equals("*")) { ouraddress=null;continue;}
  485.                                                     try{
  486.                                                     ouraddress=InetAddress.getByName(ip);
  487.                                                     }
  488.                                                     catch (IOException e) { System.err.println("Can not resolve my BindAddress: "+ip);}
  489.                                   continue;
  490.                                                     }
  491.                                                                                                         
  492.                                                     
  493.           if(token.equalsIgnoreCase("shutdown_flag")) {shutdownflag=st.nextToken();
  494.                                   continue;
  495.                                                     }
  496.           if(token.equalsIgnoreCase("mime_types")) {repair.loadMimeTypes(st.nextToken());
  497.                                   continue;
  498.                                                     }
  499.  
  500.  
  501.           if(token.equalsIgnoreCase("immediate_shutdown_flag")) {immediate_shutdownflag=st.nextToken();
  502.                                   continue;
  503.                                                     }
  504.                                                     
  505.           if(token.equals("case_sensitive_matching")) {
  506.                                              char c=(char)Integer.valueOf(st.nextToken()).intValue();
  507.                                                            if(c!=0) case_sensitive=true; else case_sensitive=false;
  508.                                                            continue;
  509.                                                       }
  510.                               
  511.           if(token.equals("auto_compress")) {
  512.                                              char c=(char)Integer.valueOf(st.nextToken()).intValue();
  513.                                                            if(c!=0) cacheobject.auto_compress=true; else cacheobject.auto_compress=false;
  514.                                                            continue;
  515.                                                       }
  516.           if(token.equals("auto_decompress")) {
  517.                                              char c=(char)Integer.valueOf(st.nextToken()).intValue();
  518.                                                            if(c!=0) cacheobject.auto_decompress=true; else cacheobject.auto_decompress=false;
  519.                                                            continue;
  520.                                                       }
  521.           if(token.equals("allowconnect")) {
  522.                                                     while(st.hasMoreTokens())
  523.                             {
  524.                                              int c;
  525.                                c=Integer.valueOf(st.nextToken()).intValue();
  526.                                allowconnect=incIntegerArraySize(allowconnect);
  527.                                allowconnect[allowconnect.length-1]=c;
  528.                             }
  529.                                                            continue;
  530.                                                       }
  531.                                                     
  532.           if(token.equalsIgnoreCase("cacheroot")) {
  533.                                     cache_dir=st.nextToken();
  534.                       if(cache_dir.endsWith(File.separator)) 
  535.                          cache_dir=cache_dir.substring(0,cache_dir.length()-File.separator.length());
  536.                     if(cache_dir.length()==2 && cache_dir.charAt(1)==':') throw new IllegalArgumentException("Smart Cache will not use root directory '"+cache_dir+"' as data storage. Use some subdirectory instead.");
  537.                               continue;
  538.                                                   }
  539.                                                     
  540.           if(token.equalsIgnoreCase("port")) {ourport=Integer.valueOf(st.nextToken()).intValue();
  541.                                   continue;
  542.                                                     }
  543.  
  544.           if(token.equalsIgnoreCase("referer_hack")) {
  545.                                                      String rh=st.nextToken();
  546.                                                     try
  547.                                                       {
  548.                                        request.referer_hack=(char)Integer.valueOf(rh).intValue();
  549.                                                       }
  550.                                                     catch (NumberFormatException e)
  551.                                                      {
  552.                               System.out.println("[ERROR] Referer_hack do not longer accept non-numeric agument `"+rh+"`.\nUse fake_referer instead.");
  553.                                                      }
  554.                                   continue;
  555.                                                     }
  556.  
  557.           if(token.equalsIgnoreCase("fake_user_agent")) {request.fake_user_agent="User-Agent:"+st.nextToken("\n");
  558.                                        continue;
  559.                                                         }
  560.  
  561.           if(token.equalsIgnoreCase("fake_referer")) {request.fake_referer="Referer:"+st.nextToken("\n");  
  562.       request.referer_hack=98;
  563.                                     continue;
  564.                                                     }
  565.                                                     
  566.           if(token.equalsIgnoreCase("swap_level1_dirs")) {swap_level1_dirs=Integer.valueOf(st.nextToken()).intValue();
  567.                                   continue;
  568.                                                     }
  569.  
  570.           if(token.equalsIgnoreCase("swap_level2_dirs")) {swap_level2_dirs=Integer.valueOf(st.nextToken()).intValue();
  571.                                   continue;
  572.                                                     }
  573.           if(token.equalsIgnoreCase("http_proxy")) {
  574.                                                     if (st.countTokens()>2) 
  575.                                                         setproxy(st.nextToken(),Integer.valueOf(st.nextToken()).intValue(),st.nextToken());
  576.                                                      else 
  577.                                                         setproxy(st.nextToken(),Integer.valueOf(st.nextToken()).intValue(),null);
  578.                             
  579.                                    continue;
  580.                                                     }
  581.           if(token.equalsIgnoreCase("access_log")) {
  582.                                                     String mask=st.nextToken();
  583.                                                     if(mask.equals("*")) mask=null;
  584.           
  585.                                                     httpreq.logpatterns=addStringToArray(mask,httpreq.logpatterns);
  586.                                                     httpreq.logfilenames=addStringToArray(st.nextToken(),httpreq.logfilenames);
  587.                                                     
  588.                                   continue;
  589.                                                     }
  590.  
  591.           if(token.equalsIgnoreCase("agent_log")) {
  592.                                                     String mask=st.nextToken();
  593.                                                     if(mask.equals("*")) mask=null;
  594.           
  595.                                                     request.alogpatterns=addStringToArray(mask,request.alogpatterns);
  596.                                                     request.alogfilenames=addStringToArray(st.nextToken(),request.alogfilenames);
  597.                                                     
  598.                                   continue;
  599.                                                     }
  600.  
  601.           if(token.equalsIgnoreCase("referer_log")) {
  602.                                                     String mask=st.nextToken();
  603.                                                     if(mask.equals("*")) mask=null;
  604.           
  605.                                                     request.rlogpatterns=addStringToArray(mask,request.rlogpatterns);
  606.                                                     request.rlogfilenames=addStringToArray(st.nextToken(),request.rlogfilenames);
  607.                                                     
  608.                                   continue;
  609.                                                     }
  610.                                                                                                                                                             
  611.                                                     
  612.  
  613.           if(token.equalsIgnoreCase("no_proxy"))   {
  614.                                                     while(st.hasMoreTokens())
  615.                                                       no_proxy=addStringToArray(st.nextToken().toLowerCase(),no_proxy);
  616.                                   continue;
  617.                                                     }
  618.           if(token.equalsIgnoreCase("serialnumber")) {
  619.                                                     /* Look at my very secure registration keys checker */
  620.                                                     
  621.                                                     // if(st.nextToken().startsWith("HTTP")) registered=true;
  622.                                                     // else
  623.                                                     //System.out.println("\t\007WARNING: Invalid serial number entered!");
  624.                                                     // registered=true;
  625.                                   continue;
  626.                                                     }
  627.  
  628.           if(token.equalsIgnoreCase("fail")) {     while(st.hasMoreTokens())
  629.                                                       fail=addRegexpToArray(st.nextToken(),fail);
  630.                                   continue;
  631.                                                     }
  632.  
  633.           if(token.equalsIgnoreCase("fail_file")) {
  634.                                                     String fn=st.nextToken();
  635.                                                     fail=parseRegexpFile(fn,fail);
  636.                                                     fail_timestamp=new File(fn).lastModified();
  637.                                                     fail_filename=fn;
  638.                                   continue;
  639.                                                     }
  640.  
  641.           if(token.equalsIgnoreCase("allow_cookies_to_file")) {
  642.                                                     String fn=st.nextToken();
  643.                                                     allow_cookies_to=parseCookieFile(fn,allow_cookies_to);
  644.                                                     cookie_timestamp=new File(fn).lastModified();
  645.                                                     cookie_filename=fn;
  646.                                   continue;
  647.                                                     }
  648.                                                     
  649.           if(token.equalsIgnoreCase("pass_file")) {
  650.                                                     String fn=st.nextToken();
  651.                                                     pass=parseRegexpFile(fn,pass);
  652.                                                     pass_timestamp=new File(fn).lastModified();
  653.                                                     pass_filename=fn;
  654.                                   continue;
  655.                                                     }
  656.                                                                                                         
  657.           if(token.equalsIgnoreCase("nocaching")) { while(st.hasMoreTokens())
  658.                                                        nocache=addRegexpToArray(st.nextToken(),nocache);
  659.                                                     cacheonly=false;
  660.                                   continue;
  661.                                                     }
  662.  
  663.           if(token.equalsIgnoreCase("wafer")
  664.       || token.equalsIgnoreCase("fake_cookie")
  665.       ) {request.wafer="Cookie:"+st.nextToken("\n");
  666.                                        continue;
  667.                                               }
  668.  
  669.           if(token.equalsIgnoreCase("pass"))      {while(st.hasMoreTokens())
  670.                                                     pass=addRegexpToArray(st.nextToken(),pass);
  671.                                  continue;
  672.                                                    }
  673.                                                     
  674.           if(token.equalsIgnoreCase("cacheonly")) {while(st.hasMoreTokens())
  675.                                                      nocache=addRegexpToArray(st.nextToken(),nocache);
  676.                                                    cacheonly=true;
  677.                                  continue;
  678.                                                     }
  679.                                                                                                         
  680.                                                                                                         
  681.           if(token.equalsIgnoreCase("redirect")) { redirfrom=addStringToArray(st.nextToken(),redirfrom);
  682.                                                    redirto=addStringToArray(st.nextToken(),redirto);
  683.                                  continue;
  684.                                                    }
  685.  
  686.           if(token.equalsIgnoreCase("quick_abort")) { 
  687.                                                    request.qa_minlen=Integer.valueOf(st.nextToken()).intValue();          
  688.                                                    request.qa_percent=Float.valueOf(st.nextToken()).floatValue();                                                   
  689.                                                    request.qa_maxlen=Integer.valueOf(st.nextToken()).intValue();                                                             
  690.                                  continue;
  691.                                                    }
  692.  
  693.           if(token.equalsIgnoreCase("errordocument")) { 
  694.                                                    int code=Integer.valueOf(st.nextToken()).intValue();          
  695.                                                    if(code==403) custom403=st.nextToken();
  696.                                                     else if(code==400 || code==500) cacheobject.custom500=st.nextToken();
  697.                                                           else
  698.                                                             System.err.println("[CONFIG_ERROR] "+cfgfile+":"+lineno+" Error code "+code+" is not customizable.");
  699.                                  continue;
  700.                                                    }
  701.                                                                                                       
  702.  
  703.           if(token.equalsIgnoreCase("max_aborted_transfer_time")) { 
  704.                                                    request.qa_maxtime=Integer.valueOf(st.nextToken()).intValue()*1000L*60L;
  705.                                  continue;
  706.                                                    }
  707.  
  708.           if(token.equalsIgnoreCase("max_clients")) { 
  709.                                                    scache.MAXHTTPCLIENTS=Integer.valueOf(st.nextToken()).intValue();
  710.                                  continue;
  711.                                                    }
  712.  
  713.           if(token.equalsIgnoreCase("inputtimeout")) { 
  714.                                                    httpreq.client_timeout=Integer.valueOf(st.nextToken()).intValue()*1000;
  715.                                  continue;
  716.                                                    }
  717.           if(token.equalsIgnoreCase("proxyreadtimeout")) { 
  718.                                                    request.read_timeout=Integer.valueOf(st.nextToken()).intValue()*1000;
  719.                                  continue;
  720.                                                    }
  721.                                                    
  722.                                                    
  723.           if(token.equalsIgnoreCase("pragma_no_cache")) { 
  724.                                                    request.pnocache=(char)Integer.valueOf(st.nextToken()).intValue();
  725.                                  continue;
  726.                                                    }
  727.           if(token.equalsIgnoreCase("append_via"  )) { 
  728.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  729.                                                    if(z!=0) request.append_via=true; else
  730.                                                             request.append_via=false;
  731.                                  continue;
  732.                                                    }
  733.           if(token.equalsIgnoreCase("keep_deleted")) { 
  734.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  735.                                                    if(z!=0) cacheobject.keep_deleted=true; else
  736.                                                     cacheobject.keep_deleted=false;
  737.                                  continue;
  738.                                                    }
  739.  
  740.           if(token.equalsIgnoreCase("cache_password_protected")) { 
  741.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  742.                                                    if(z!=0) request.cache_protected=true; else
  743.                                                     request.cache_protected=false;
  744.                                  continue;
  745.                                                    }
  746.                                                    
  747.           if(token.equalsIgnoreCase("remove_pragma_no_cache")) { 
  748.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  749.                                                    if(z!=0) request.remove_pragma_no_cache=true; else
  750.                                                     request.remove_pragma_no_cache=false;
  751.                                  continue;
  752.                                                    }
  753.  
  754.           if(token.equalsIgnoreCase("fail_trace")) { 
  755.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  756.                                                    if(z!=0) fail_trace=true; else
  757.                                                     fail_trace=false;
  758.                                  continue;
  759.                                                    }
  760.           if(token.equalsIgnoreCase("clear_flags_on_start")) { 
  761.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  762.                                                    if(z!=0) clear_flags_on_start=true; else
  763.                                                     clear_flags_on_start=false;
  764.                                  continue;
  765.                                                    }
  766.           if(token.equalsIgnoreCase("flag_check_interval")) { 
  767.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  768.                                                    flag_check_interval=z;
  769.                                  continue;
  770.                                                    }
  771.          if(token.equalsIgnoreCase("reload_block_files")) {
  772.                             // ABSOLETE: now always enabled
  773.                                  continue;
  774.                                                    }
  775.                                                                                                       
  776.           if(token.equalsIgnoreCase("generate_lastmod")) { 
  777.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  778.                                                    cacheobject.generate_lastmod=z;
  779.                                  continue;
  780.                                                    }
  781.  
  782.           if(token.equalsIgnoreCase("hide_errors")) { 
  783.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  784.                                                    if(z!=0) cacheobject.hide_errors=true; else
  785.                                                     cacheobject.hide_errors=false;
  786.                                  continue;
  787.                                                    }
  788.  
  789.           if(token.equalsIgnoreCase("full_referer_log")) { 
  790.                                                    int z=Integer.valueOf(st.nextToken()).intValue();
  791.                                                    if(z!=0) request.full_referer_log=true; else
  792.                                                     request.full_referer_log=false;
  793.                                  continue;
  794.                                                    }
  795.                                                    
  796.           if(token.equalsIgnoreCase("allow")) {
  797.                            while(st.hasMoreElements())
  798.                            {
  799.                                                String adr;
  800.                            adr=st.nextToken();
  801.                                                if(adr.equals("*")) httpreq.allowed=null;
  802.                            else
  803.                                                httpreq.allowed=addInetAdrToArray(InetAddress.getByName(adr),httpreq.allowed);
  804.                            }
  805.                            continue;
  806.                           }
  807.           if(token.equalsIgnoreCase("default_refresh_pattern")) 
  808.                                                     {
  809.                                                     reload_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  810.                                                     min_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  811.                                                     lmfactor=Float.valueOf(st.nextToken()).floatValue();
  812.                                                     max_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  813.                                                     if(reload_age>min_age) reload_age=min_age/2;
  814.                                                     if(max_age<=min_age) max_age=min_age+1000L*60L*60L*48L;
  815.                             if(st.countTokens()>0)
  816.                             {
  817.                                                       expire_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  818.                                                       redir_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  819.                             } else
  820.                             System.out.println("[WARNING] default_refresh_pattern can have additional arguments.");
  821.                             if(expire_age>max_age) expire_age=max_age;
  822.                             if(redir_age>min_age) redir_age=min_age;
  823.                                   continue;
  824.                                                     }
  825.           if(token.equalsIgnoreCase("refresh_pattern")) 
  826.                                                     {
  827.                                                     String url=st.nextToken();
  828.                                                     if(isInRegexpArray(url,refresh)) continue;
  829.                                                     long xreload_age=(long)Float.valueOf(st.nextToken()).floatValue()*1000L*60L;
  830.                                                     long xmin_age=(long)Float.valueOf(st.nextToken()).floatValue()*1000L*60L;
  831.                                                     float xlmfactor=Float.valueOf(st.nextToken()).floatValue();
  832.                                                     long xmax_age=(long)Float.valueOf(st.nextToken()).floatValue()*1000L*60L;
  833.                                                     if(xreload_age>xmin_age) xreload_age=xmin_age/4;
  834.                                                     if(xmax_age<=xmin_age) xmax_age=xmin_age+1000L*60L*60L*48L;
  835.                             long xexpire_age,xredir_age;
  836.                             if(st.countTokens()>0)
  837.                             {
  838.                                                       xexpire_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  839.                                                       xredir_age=(long)(Float.valueOf(st.nextToken()).floatValue()*1000L*60L);
  840.                             } else
  841.                             { 
  842.                                System.out.println("[WARNING] refresh_pattern can have additional arguments.");
  843.                                xexpire_age=5*60*1000L;
  844.                                xredir_age=10*1000L;
  845.                             }
  846.                             
  847.                             if(xexpire_age>xmax_age) xexpire_age=xmax_age;
  848.                             if(xredir_age>xmin_age) xredir_age=xmin_age;
  849.                                                     /* pridat do pole */
  850.                                                     refresh=addRegexpToArray(url,refresh);
  851.                                                     /* natahnout ! */
  852.                                                     reloadage=incLongArraySize(reloadage);
  853.                                                     minage=incLongArraySize(minage);
  854.                                                     maxage=incLongArraySize(maxage);
  855.                                                     expireage=incLongArraySize(expireage);
  856.                                                     redirage=incLongArraySize(redirage);
  857.                                                     lastmodf=incFloatArraySize(lastmodf);
  858.                                                     
  859.                                                     /* nastavit hodnoty */
  860.                                                     reloadage[reloadage.length-1]=xreload_age;
  861.                                                     minage[minage.length-1]=xmin_age;
  862.                                                     maxage[maxage.length-1]=xmax_age;
  863.                                                     lastmodf[lastmodf.length-1]=xlmfactor;
  864.                                                     expireage[expireage.length-1]=xexpire_age;
  865.                                                     redirage[redirage.length-1]=xredir_age;
  866.                                   continue;
  867.                                                     }
  868.                                                     
  869.                                                                                                                                                             
  870.           System.out.println("[CONFIG_ERROR] Unknown keyword "+token+" in "+cfgfile+":"+lineno);  
  871.      }
  872.      catch (NoSuchElementException nse)
  873.            { System.out.println("[CONFIG_ERROR] "+cfgfile+":"+lineno+" Missing arguent(s).");
  874.              continue;}                                     
  875.      catch (NumberFormatException nse)
  876.            { System.out.println("[CONFIG_ERROR] "+cfgfile+":"+lineno+" Invalid Number Format.");
  877.              continue;}                                     
  878.              
  879.      
  880.  }/* while */
  881.  dis.close();
  882.    
  883.  }
  884.  catch(FileNotFoundException kiss)
  885.   { System.out.println("[WARNING] No config file ("+cfgfile+") found, using defaults.");}  
  886.  catch(IOException e) 
  887.   { System.out.println("I/O Error reading config file "+cfgfile);}
  888.  
  889.  // init access log filez 
  890.  if(httpreq.logpatterns!=null) httpreq.logfilez=new DataOutputStream[httpreq.logpatterns.length];
  891.  
  892.  // init agent log filez 
  893.  if(request.alogpatterns!=null) request.alogfilez=new DataOutputStream[request.alogpatterns.length];
  894.  
  895.  // init referer log filez 
  896.  if(request.rlogpatterns!=null) request.rlogfilez=new DataOutputStream[request.rlogpatterns.length];
  897.  
  898.  if(swap_level1_dirs<1) swap_level1_dirs=1;
  899.  if(swap_level2_dirs<1) swap_level2_dirs=1;
  900. }
  901.  
  902. public final void setproxy(String hostname,int port,String auth)
  903. {
  904.  if (auth!=null) parentauth="Proxy-authorization: Basic "+HTUU.encode_string(auth); else parentauth=null;
  905.  try{
  906.  parentproxy=InetAddress.getByName(hostname);
  907.  this.port=port;
  908. // System.out.println("My parent proxy is "+hostname+" port "+port);
  909.  }
  910.  catch (UnknownHostException e) 
  911.   {
  912.    System.err.println("[WARNING] Can not resolve parent proxy hostname: "+hostname+" - running without it.");
  913.    parentproxy=null;
  914.    no_proxy=null;
  915.    parentauth=null;
  916.    this.port=0;
  917.   }
  918. }
  919.  
  920. final public void process_request(request req) throws MalformedURLException, IOException
  921. {
  922.  boolean allowed;
  923.  allowed=false;
  924.  
  925.  String requested=req.getURL();
  926.  
  927.  /* HANDLE  REWRITE ! */
  928.  if(redirfrom!=null)
  929.   {
  930.    String fragment;
  931.    int j=redirfrom.length;
  932.    for(int i=0;i<j;i++)
  933.    {
  934.     fragment=simpleWildMatch(redirfrom[i], requested);
  935.     if(fragment==null) continue;
  936.     if(is_wild(redirto[i])) 
  937.      //req.make_headers(301,"text/html",redirto[i].substring(0,redirto[i].length()-1)+fragment,0,0,0);
  938.        req.rewriteURL(redirto[i].substring(0,redirto[i].length()-1)+fragment);
  939.      else
  940.        // req.make_headers(301,"text/html",redirto[i],0,0,0);
  941.        req.rewriteURL(redirto[i]);
  942.  
  943.     requested=req.getURL(); // reread URL
  944.     break;          
  945.    }
  946.   } /* redir handler end */
  947.  
  948.  
  949.  try
  950.  {
  951.  /* is URL in allowed list ? */
  952.  if(pass!=null)
  953.   {
  954.   
  955.    int j=pass.length;
  956.    for(int i=0;i<j;i++)
  957.     if(pass[i].matches(requested))
  958.      { allowed=true;break;}
  959.   }
  960.  }
  961.  catch (IndexOutOfBoundsException ignore) {}
  962.  
  963.  try
  964.  {
  965.  /* is URL blocked ? */ 
  966.  if(fail!=null && allowed==false)
  967.   {
  968.   
  969.    int j=fail.length;
  970.    for(int i=0;i<j;i++)
  971.    {
  972.     if(fail[i].matches(requested))
  973.      { 
  974.        cacheobject.c_block++; //STAT
  975.        if(fail_trace)
  976.        {
  977.          System.out.println("Blocked: " +requested+"\n\tby rule: \""+fail[i]+"\"");
  978.        }
  979.        if(custom403==null) req.send_error(403,"Forbidden by rule");
  980.          else
  981.             if(custom403.charAt(0)=='0') {
  982.             req.make_headers(200,"image/gif",null,null,43,886828316241L,0);
  983.         req.send_headers();
  984.         req.sendBytes(req.GIF);
  985.           }
  986.         else 
  987.             if(custom403.charAt(0)=='-') { 
  988.                                        req.send_error(204,"No Content");  
  989.                                        }
  990.             else if(custom403.charAt(0)=='!')
  991.               {
  992.                  req.make_headers(200,"text/html",null,null,0,new Date().getTime(),0);
  993.                  req.send_headers();
  994.                  req.sendString("<HTML></HTML>");
  995.               }                                       
  996.                   else
  997.                    { req.make_headers(301,null,null,custom403,0,new Date().getTime(),0);
  998.                      req.send_headers();
  999.                    }
  1000.                 
  1001.        req.close();
  1002.        return;
  1003.        }
  1004.    }
  1005.   
  1006.   }
  1007.   
  1008.  }
  1009.  catch (IndexOutOfBoundsException ignore) {}
  1010.   
  1011.   /* NO-CACHE HANDLER */
  1012.     
  1013.   if(nocache!=null)
  1014.    { // if(cacheonly) req.nocache();
  1015.    
  1016.      int j=nocache.length;
  1017.      int i;
  1018.      
  1019.      toploop:while(true)
  1020.      {
  1021.      for(i=0;i<j;i++)
  1022.        {
  1023.          if(nocache[i].matches(requested))
  1024.            {
  1025.             if(!cacheonly) req.nocache();
  1026.             break toploop;              
  1027.            }
  1028.        } /* for */
  1029.          if(cacheonly) req.nocache();    
  1030.          break;   
  1031.       } /* toploop */
  1032.    }
  1033.    
  1034.  String[] parsed;
  1035.  parsed=parseURL(requested,req.getProtocol());
  1036.  String host=parsed[0];
  1037.  
  1038.  try
  1039.  {
  1040.  /* C00KIES FILTER */
  1041.  if(allow_cookies_to!=null)
  1042.   {
  1043.    cookieloop:while(true)
  1044.    {
  1045.     for(int i=allow_cookies_to.length-1;i>=0;i--)
  1046.      if(host.endsWith(allow_cookies_to[i])) { break cookieloop;}
  1047.    
  1048.    req.removeCookies();
  1049.    break;
  1050.    }
  1051.   }
  1052.  }
  1053.  catch (IndexOutOfBoundsException ignore) {}
  1054.  
  1055.  /* USE PARENT PROXY SERVER ?? */
  1056.  boolean direct;
  1057.  if(parentproxy==null) direct=true;
  1058.   else
  1059.   {
  1060.      direct=false;
  1061.      if(no_proxy!=null) {
  1062.         int j=no_proxy.length;
  1063.         for(int i=0;i<j;i++) {
  1064.            if(host.endsWith(no_proxy[i])) {
  1065.               direct=true;
  1066.               break;
  1067.               }
  1068.            }
  1069.         } /* if No_proxy */
  1070.   }
  1071.  if(direct)
  1072.  {
  1073.  /* DIREKT REZIM - klidek */
  1074.  try{
  1075.    req.setTarget(InetAddress.getByName(host),parsed[1]==null? 80: Integer.valueOf(parsed[1]).intValue());
  1076.  }
  1077.  catch (UnknownHostException e) { req.setTarget(null,80); }
  1078.  catch (NumberFormatException e) { req.send_error(400,"Port is not a numeric constant: "+parsed[1]); }
  1079.  
  1080.  /* premenime request na normal */
  1081.  if(parsed[4]!=null) req.send_error(501,"Protocol "+parsed[4]+" is not directly supported, configure http_proxy.");
  1082.  req.setRequestTo(parsed[2]+parsed[3]);
  1083.  }
  1084.  else
  1085.  {
  1086.    req.setTarget(parentproxy,port);
  1087.    if (parentauth!=null) req.add_header(parentauth);
  1088.  }
  1089.  
  1090.  /* testneme na non HEAD/GET methods */
  1091.   switch(req.getMethod())
  1092.   {
  1093.    case httpreq.REQUEST_POST:
  1094.    case httpreq.REQUEST_PUT:  
  1095.                                req.addHost(host,parsed[1]);
  1096.                                req.direct_request(true);
  1097.                                return;
  1098.    case httpreq.REQUEST_TRACE: 
  1099.                                req.handle_trace();
  1100.                    return;
  1101.    case httpreq.REQUEST_OPTIONS:
  1102.                                req.addHost(host,parsed[1]);
  1103.                                req.handle_options();
  1104.                    return;
  1105.    case httpreq.REQUEST_DELETE: 
  1106.                                req.addHost(host,parsed[1]);
  1107.                                req.direct_request(false);
  1108.                                return;
  1109.   case httpreq.REQUEST_CONNECT:
  1110.                                 {
  1111.                  int port=80;
  1112.                                  if(parsed[1]!=null) 
  1113.                    try
  1114.                     { port=Integer.valueOf(parsed[1]).intValue();}
  1115.                                     catch (NumberFormatException e) { req.send_error(400,"Port is not a numeric constant:"+parsed[1]); }
  1116.  
  1117.                                  if(allowconnect==null) req.send_error(501,"CONNECCT method is disabled by configuration.");
  1118.                    /* Always go direct! */
  1119.                    try
  1120.                    {
  1121.                                     req.setTarget(InetAddress.getByName(host),port);}
  1122.                                    catch (UnknownHostException e) 
  1123.                                      { req.send_error(500,"CONNECT failed: "+host+" Host unknown.");}
  1124.                  for(int i=allowconnect.length-1;i>=0;i--)
  1125.                  {
  1126.                    if(allowconnect[i]==port)
  1127.                     {
  1128.                      req.handle_connect();
  1129.                      return;
  1130.                     }
  1131.                  }
  1132.                                  req.send_error(403,"Direct connecting to port "+parsed[1]+" is forbidden by rule.");
  1133.                 }
  1134.   }
  1135.  
  1136.  req.addHost(host,parsed[1]); /* pridat Host: hlavicku */
  1137.  
  1138.  /* konverze na local dir */
  1139.  String locdir=getLocalDir(host,parsed[1],parsed[2],parsed[4]);
  1140.  cachedir dir=null;
  1141.  try{
  1142.       dir=getDir(locdir);
  1143.     }
  1144.  catch(Exception e) { e.printStackTrace();
  1145.                       System.out.println("Hostname:"+host);
  1146.                       System.out.println("Port:"+parsed[1]);
  1147.                       System.out.println("Dir:"+parsed[2]);
  1148.                       req.close();
  1149.                       return;
  1150.                     }
  1151.  cacheobject cobj;
  1152.  cobj=dir.getObject(parsed[3]);
  1153.  
  1154.  /* HANDLE REFRESH PATTERNS MIN_AGE, PERCENT, MAX_AGE */
  1155.  if(refresh!=null)
  1156.   {
  1157.    int refreshcache=refresh.length;
  1158.    for(int i=0;i<refreshcache;i++)
  1159.     if(refresh[i].matches(requested))
  1160.      {
  1161.      cobj.make_request(req,reloadage[i],minage[i],maxage[i],lastmodf[i],expireage[i],redirage[i]);
  1162.      break;
  1163.      }
  1164.   
  1165.   }
  1166.   else
  1167.    cobj.make_request(req,reload_age,min_age,max_age, lmfactor,expire_age,redir_age);
  1168.  
  1169.  req.close();
  1170. }
  1171.  
  1172. final private synchronized cachedir getDir(String locdir)
  1173. { 
  1174.  cachedir dir=(cachedir)dircache.get(locdir);
  1175.  if(dir!=null) return dir;
  1176.  
  1177.  dir=new cachedir(locdir); 
  1178.  dircache.put(locdir,dir);
  1179.  return dir;
  1180. }
  1181.  
  1182. final public void run()
  1183. {
  1184.  int ticks;
  1185.  if(immediate_shutdownflag==null || flag_check_interval<=0) 
  1186.        flag_check_interval=(int)(SAVETIMER/1000);
  1187.  /* normalize fci */
  1188.  ticks=(int)(SAVETIMER/1000/flag_check_interval);
  1189.  if(ticks==0) ticks=1;
  1190.  flag_check_interval=(int)(SAVETIMER/1000/ticks);
  1191.  long sleeptime=flag_check_interval*1000L;
  1192.  int i=0;
  1193.  // System.out.println("[debug] ticks="+ticks+" sleeptime="+sleeptime/1000);
  1194.  while(true)
  1195.  {
  1196.  
  1197.  try{
  1198.  Thread.sleep(sleeptime);
  1199.  }
  1200.  catch (InterruptedException e) 
  1201.  { 
  1202.    System.out.println("[Smart Cache] Background saver Interrupted, exiting.");
  1203.    save();save();break;
  1204.  }
  1205.  i++;
  1206.  if(i>=ticks) { save();i=0;}
  1207.  /* check 4 IMM shutdownflag */
  1208.   if(checkFlag(immediate_shutdownflag))
  1209.    {
  1210.     Enumeration e2=dircache.elements();
  1211.     while(e2.hasMoreElements())
  1212.     {
  1213.      cachedir d;
  1214.      d=(cachedir) e2.nextElement();
  1215.      d.save();
  1216.      d.cleandir(); /* if needed */ 
  1217.     }
  1218.     httpreq.flush(httpreq.logfilez);
  1219.     httpreq.flush(request.alogfilez);
  1220.     httpreq.flush(request.rlogfilez);
  1221.     System.out.println(new Date()+" Server stoped by Immediate shutdown flag.");System.exit(0);
  1222.    }
  1223.  
  1224.   // reloading block files
  1225.     if(pass_filename!=null)
  1226.      {
  1227.       if(new File(pass_filename).lastModified()!=pass_timestamp)
  1228.       {
  1229.        System.out.println(new Date()+" Reloading Pass_file "+pass_filename);
  1230.        pass=parseRegexpFile(pass_filename,null);
  1231.        pass_timestamp=new File(pass_filename).lastModified();
  1232.       }
  1233.      }
  1234.  
  1235.     if(fail_filename!=null)
  1236.      {
  1237.       if(new File(fail_filename).lastModified()!=fail_timestamp)
  1238.       {
  1239.        System.out.println(new Date()+" Reloading fail_file "+fail_filename);
  1240.        fail=parseRegexpFile(fail_filename,null);
  1241.        fail_timestamp=new File(fail_filename).lastModified();
  1242.       }
  1243.      }
  1244.         
  1245.     if(cookie_filename!=null)
  1246.      {
  1247.       if(new File(cookie_filename).lastModified()!=cookie_timestamp)
  1248.       {
  1249.        System.out.println(new Date()+" Reloading allow_cookies_to_file "+cookie_filename);
  1250.        allow_cookies_to=parseCookieFile(cookie_filename,null);
  1251.        cookie_timestamp=new File(cookie_filename).lastModified();
  1252.       }
  1253.      }
  1254.  }
  1255.  
  1256. }
  1257.  
  1258. /* Ulozi hashtabulku na disk */
  1259. final private void save()
  1260. {
  1261.  int saved=0;
  1262.  int cleaned=0;
  1263.  Enumeration e1=dircache.keys();
  1264.  Enumeration e2=dircache.elements();
  1265.  while(e1.hasMoreElements())
  1266.  {
  1267.   cachedir d;
  1268.   d=(cachedir) e2.nextElement();
  1269.   String key;
  1270.   key=(String) e1.nextElement();
  1271.   
  1272.   if(d.dirty==true) { d.save(); saved++;}
  1273.     else
  1274.                   { dircache.remove(key);
  1275.                     d.cleandir(); /* if needed */ 
  1276. //                  System.err.println("[DIRGC] "+key);
  1277.                     cleaned++;}
  1278.  
  1279.  }
  1280.  httpreq.flush(httpreq.logfilez);
  1281.  httpreq.flush(request.alogfilez);
  1282.  httpreq.flush(request.rlogfilez);
  1283.  
  1284.  /* STATs */
  1285.  DataOutputStream dos=null;
  1286.  if(stat_log!=null)
  1287.  try
  1288.  {
  1289.    dos=new DataOutputStream(new BufferedOutputStream(
  1290.    new FileOutputStream(stat_log,true),4096));
  1291.  }
  1292.    catch (IOException ee1)
  1293.    {
  1294.           System.err.println("Problem creating stat_log file "+stat_log+" - turning it off.");
  1295.           stat_log=null;
  1296.    }
  1297.  
  1298.  if(saved>0)
  1299.  {
  1300.    StringBuffer sb=new StringBuffer(100);
  1301.    sb.append(new Date().toString());
  1302.    sb.append(" - ");
  1303.    sb.append(
  1304.    (int)(
  1305.    100.0f*(cacheobject.c_hit+cacheobject.c_block)  /  
  1306.    ((float)cacheobject.c_hit+cacheobject.c_block
  1307.                 +cacheobject.c_miss+cacheobject.c_refresh)
  1308.         )   );
  1309.    sb.append("% REQS: ");
  1310.    sb.append(cacheobject.c_hit);
  1311.    sb.append(" Hit, ");
  1312.    sb.append(cacheobject.c_refresh);
  1313.    sb.append(" Refresh, ");
  1314.    sb.append(cacheobject.c_miss);
  1315.    sb.append(" Miss, ");
  1316.    sb.append(cacheobject.c_block);
  1317.    sb.append(" Block.");
  1318.    System.out.println(sb);
  1319.    if(dos!=null)
  1320.      try
  1321.       {
  1322.         dos.writeBytes(sb.toString());
  1323.         dos.writeBytes("\n");
  1324.       }
  1325.       catch (IOException ignore) {}
  1326.    
  1327.    // clear the stats
  1328.    cacheobject.c_hit=cacheobject.c_miss=cacheobject.c_refresh=cacheobject.c_block
  1329.    =0;
  1330.  }
  1331.  if(cacheobject.b_miss+cacheobject.b_hit>0)
  1332.  {
  1333.    StringBuffer sb=new StringBuffer(100);
  1334.    sb.append(new Date());
  1335.    sb.append(" - ");
  1336.    sb.append(
  1337.    (int)(
  1338.    100.0f*cacheobject.b_hit/((float)cacheobject.b_miss+cacheobject.b_hit)
  1339.    )         );
  1340.    sb.append("% BYTES: ");
  1341.    sb.append(cacheobject.b_miss);
  1342.    sb.append(" B in, ");
  1343.    sb.append(cacheobject.b_miss+cacheobject.b_hit);
  1344.    sb.append(" B out.");
  1345.    System.out.println(sb);
  1346.    if(dos!=null)
  1347.      try
  1348.       {
  1349.         dos.writeBytes(sb.toString());
  1350.         dos.writeBytes("\n");
  1351.       }
  1352.       catch (IOException ignore) {}
  1353.    
  1354.    // clear the stats
  1355.    cacheobject.b_hit=cacheobject.b_miss=0;
  1356.   }
  1357.   /* close stat_logfile */
  1358.   if(dos!=null)
  1359.    try
  1360.     { dos.close();}
  1361.    catch (IOException err)
  1362.     {
  1363.      stat_log=null;
  1364.     }
  1365.  
  1366.  if(saved>0 || cleaned> 0) 
  1367.   {
  1368.    System.out.println(new Date().toString()+" - DIRS: "+saved+" saved, "+cleaned+" garbage collected.");
  1369.   }
  1370.  if(saved==0)
  1371.   { 
  1372.    httpreq.close(httpreq.logfilez);
  1373.    httpreq.close(request.alogfilez);
  1374.    httpreq.close(request.rlogfilez);   
  1375.  
  1376.    if(checkFlag(shutdownflag)) 
  1377.          { System.out.println(new Date()+" Server stoped by shutdown flag.");System.exit(0);}
  1378.   }
  1379.   
  1380.   
  1381.      
  1382. } /* save end */
  1383.  
  1384. /*  prechrousta URL a vrati
  1385. 0 - hostname
  1386. 1 - port (if any) jinak null
  1387. 2 - directory
  1388. 3 - file including query string ("" if empty)
  1389. 4 - protocol (null if http)
  1390. */
  1391.  
  1392. final public static String[] parseURL(String url,String proto)
  1393. {
  1394.   String[] res=new String[5];
  1395.   res[3]=""; /* HashTable do not likes NULL */
  1396.   int i,j,seven;
  1397.   if(proto!=null)
  1398.   {
  1399.   /* protocol check */
  1400.   res[4]=proto;
  1401.   seven=proto.length()+3; /* '://' */
  1402.   
  1403.   if(seven==7)
  1404.    {
  1405.     char c;
  1406.     c=proto.charAt(0);
  1407.     if(c=='h' || c=='H') res[4]=null;
  1408.    }
  1409.   }else { res[4]=null;seven=0;}
  1410.   i=url.indexOf('/',seven);
  1411.   if(i==-1) { url+='/'; i=url.length()-1;}
  1412.   
  1413.   j=url.indexOf(':',seven);
  1414.   /* http://zero.dsd:434/ */
  1415.   if(j!=-1 && j<i)  /* mame tu portname */
  1416.                     {
  1417.                       res[0]=url.substring(seven,j).toLowerCase();
  1418.                       res[1]=url.substring(j+1,i);
  1419.                       if(res[1].equals("80")) res[1]=null;
  1420.                     }
  1421.            else
  1422.              {
  1423.               res[0]=url.substring(seven,i).toLowerCase();
  1424.              }
  1425.  
  1426.   /* parse adr */
  1427.   
  1428.   /* najdeme nejvice vlevo z moznych debilnich znaku */
  1429.   
  1430.    j=url.length()-1;
  1431.    byte v[];
  1432.    v=new byte[j+1];
  1433.    url.getBytes(i,j+1,v,i);
  1434.    // getChars(i,j,v,0);
  1435.    loop1:for(int zz=i;zz<=j;zz++)
  1436.     {
  1437.     switch(v[zz])
  1438.     {
  1439.     case 0x3b: // ;
  1440.     case 0x3a: // :
  1441.     case 0x3d: // =
  1442.     case 0x3f: // ?
  1443.               j=zz;break loop1;
  1444.     case 0x23: // #
  1445.      url=url.substring(0,zz);break loop1;
  1446.     }
  1447.     }
  1448.       
  1449.    
  1450.    j=url.lastIndexOf('/',j);
  1451.  
  1452.   String adr=url.substring(i,j+1); // adresar
  1453.   /* Normalize URL - remove /../ */
  1454.   /* NOTE: /./ should be also removed, but it do not hurt anything? */
  1455.   while( (i=adr.indexOf("/../")) >= 0 ) 
  1456.   {
  1457.    /* DEBUG: 
  1458.    */
  1459.    int l;
  1460.    if( (l=adr.lastIndexOf('/',i-1)) >=0 )
  1461.       adr= adr.substring(0,l)+ adr.substring(i+3);
  1462.    else
  1463.      adr=adr.substring(i+3);
  1464.   }
  1465.   res[2]=adr;
  1466.   if(j+1!=url.length()) res[3]=url.substring(j+1);
  1467.   return res;  
  1468. }
  1469.  
  1470. final public String getLocalDir(String host,String port,String urldir,String proto)
  1471. {
  1472. /***
  1473. Host - zero.vole.cz:3333
  1474. urldir = /ddfgfds/rerew/ - musi koncit s /
  1475. */
  1476.   StringBuffer result=new StringBuffer(80);
  1477.   result.append(cache_dir);
  1478.   int i;
  1479.   
  1480.   /* 1. spocitat hash z host stringu */
  1481.   CRC32 crc=new CRC32();
  1482.   
  1483.   // host=host.toLowerCase();  
  1484.   crc.update(host.getBytes());
  1485.                            
  1486.   /* mame hash - rozdelime ho na adresar */
  1487. //  System.out.println("value="+i);  
  1488.   /* zacneme budovat cestu */
  1489.       i=(int)(crc.getValue()/(0x100000000L/(swap_level1_dirs*swap_level2_dirs)));
  1490.       result.append(File.separator+(i/swap_level2_dirs)+File.separator+(i % swap_level2_dirs)+File.separator+host);
  1491.       
  1492.   /* pridame port */
  1493.   if(port!=null)
  1494.    {result.append('_');
  1495.     result.append(port);
  1496.    }
  1497.  
  1498.   /* add protocol */
  1499.   if(proto!=null) 
  1500.              {
  1501.               result.append('^');
  1502.               result.append(proto);
  1503.              }
  1504.   
  1505.   /* pridame adresar */
  1506.   if(File.separatorChar!='/') urldir=urldir.replace('/',File.separatorChar);
  1507.   
  1508.   /* *************************************************** */
  1509.   /* ALERT: Synchronize by hand with garbage.encodechars */
  1510.   /* *************************************************** */
  1511.   /* nahrazujeme nepratelske znaky */
  1512.   // urldir=urldir.replace(':','_');
  1513.   // zde to neni nutne, neb muze byt jen v portu
  1514.   
  1515.   //  urldir=urldir.replace('*','@');
  1516.   //  urldir=urldir.replace('?','#');  
  1517.   // urldir=urldir.replace('~','-');
  1518.   
  1519.   // these two are not needed. Browsers sends < >
  1520.   // urldir=urldir.replace('>','}');  
  1521.   // urldir=urldir.replace('<','{');
  1522.   urldir=urldir.replace('|','!');
  1523.   
  1524.   result.append(urldir);
  1525.   return result.toString();
  1526. }
  1527.  
  1528. /* U T I L I T Y */
  1529.  
  1530. final static String[] addStringToArray(String what,String[] array)
  1531. {
  1532.  //if(what==null) return array;
  1533.  if(array==null) { array=new String[1];array[0]=what;return array;}
  1534.  String[] tmp;
  1535.  int ar=array.length;
  1536.  tmp=new String[ar+1];
  1537.  System.arraycopy(array,0,tmp,0,ar);
  1538.  tmp[ar]=what;
  1539.  return tmp;
  1540. }
  1541.  
  1542. final static String[] reverseStringArray(String[] what)
  1543. {
  1544.  String res[];
  1545.  if(what==null) return null;
  1546.  res=new String[what.length];
  1547.  for(int i=0;i<what.length;i++)
  1548.   res[what.length-1-i]=what[i];
  1549.  
  1550.  return res;
  1551. }
  1552.  
  1553. final static regexp[] reverseRegexpArray(regexp[] what)
  1554. {
  1555.  regexp res[];
  1556.  if(what==null) return null;
  1557.  res=new regexp[what.length];
  1558.  for(int i=0;i<what.length;i++)
  1559.   res[what.length-1-i]=what[i];
  1560.  
  1561.  return res;
  1562. }
  1563.  
  1564. final static regexp[] addRegexpToArray(String what,regexp[] array)
  1565. {
  1566.  if(what==null) return array;
  1567.  if(array==null) { array=new regexp[1];array[0]=new regexp(what,true);return array;}
  1568.  /* test zda tam uz nejsme */
  1569.  for(int i=0;i<array.length;i++)
  1570.   if(array[i].matches(what)) { System.err.println("[INFO] Rule \""+what+"\" ignored, already matched by \""+array[i]+"\"");return array;}
  1571.   
  1572.  regexp[] tmp;
  1573.  tmp=new regexp[array.length+1];
  1574.  System.arraycopy(array,0,tmp,0,array.length);
  1575.  tmp[array.length]=new regexp(what,!case_sensitive);
  1576.  return tmp;
  1577. }
  1578.  
  1579. final static boolean isInRegexpArray(String what,regexp[] array)
  1580. {
  1581.  if(array==null) return false;
  1582.  for(int i=0;i<array.length;i++)
  1583.   if(array[i].matches(what)) { return true;}
  1584.  return false;
  1585. }
  1586.  
  1587.  
  1588. final public static int [] incIntegerArraySize(int[] array)
  1589. {
  1590.  if(array==null) { array=new int[1];return array;}
  1591.  int[] tmp;
  1592.  tmp=new int[array.length+1];
  1593.  System.arraycopy(array,0,tmp,0,array.length);
  1594.  return tmp;
  1595. }
  1596.  
  1597. final public static long[] incLongArraySize(long[] array)
  1598. {
  1599.  if(array==null) { array=new long[1];return array;}
  1600.  long[] tmp;
  1601.  tmp=new long[array.length+1];
  1602.  System.arraycopy(array,0,tmp,0,array.length);
  1603.  return tmp;
  1604. }
  1605.  
  1606. final public static float[] incFloatArraySize(float[] array)
  1607. {
  1608.  if(array==null) { array=new float[1];return array;}
  1609.  float[] tmp;
  1610.  tmp=new float[array.length+1];
  1611.  System.arraycopy(array,0,tmp,0,array.length);
  1612.  return tmp;
  1613. }
  1614.  
  1615.  
  1616. /* SIMPLE WILD CARD REGEXP */
  1617.  
  1618. /* hvezdicka muze byt jen na konci retezce */
  1619. /* TODO: predelat na regionmatches */
  1620.  
  1621. final public static String simpleWildMatch(String mask, String test)
  1622. {
  1623.  String lastmatch;
  1624.  if(mask==null) return test;
  1625.  int i=mask.indexOf('*',0);
  1626.  if(i==-1) {
  1627.             if(test.equals(mask)) return test;
  1628.              else
  1629.                return null;
  1630.            }
  1631.  int tl=test.length();
  1632.  int ml=mask.length();          
  1633.  if(i!=ml-1) throw new IllegalArgumentException("* is not at end of string "+mask);
  1634.  //if(test.startsWith(mask.substring(0,ml-1)))
  1635.  
  1636.  if(test.regionMatches(0,mask,0,ml-1))
  1637.  
  1638.   if (tl>=ml) return test.substring(ml-1);
  1639.           else
  1640.               return "";
  1641.   
  1642.  return null;
  1643. }
  1644.  
  1645. final public void garbage_collection()
  1646. {
  1647.  System.out.println(new Date()+" running garbage collection");
  1648.  garbage g=new garbage(cache_dir);
  1649.  g.garbage_collection();
  1650.  System.out.println(new Date()+" operation ended");
  1651. }
  1652.  
  1653. final public void rebalance()
  1654. {
  1655.  System.out.println(new Date()+" rebalancing directories to "+swap_level1_dirs+"/"+swap_level2_dirs+" levels.");
  1656.  garbage g=new garbage(cache_dir);
  1657.  g.rebalance();
  1658.  System.out.println(new Date()+" operation ended");
  1659. }
  1660.  
  1661. final public void cacheimport(String d)
  1662. {
  1663.  repair.quiet=true;
  1664.  repair.nosave=true;
  1665.  repair.force=false;
  1666.  System.out.println(new Date()+" importing from cache on "+d);
  1667.  garbage g=new garbage(cache_dir);
  1668.  g.cacheimport(d);
  1669.  System.out.println(new Date()+" operation ended");
  1670. }
  1671.  
  1672. final public void cacheexport(String d,int type,long diff)
  1673. {
  1674.  repair.quiet=true;
  1675.  repair.nosave=true;
  1676.  repair.force=false;
  1677.  System.out.println(new Date()+" exporting cache to "+d);
  1678.  garbage g=new garbage(cache_dir);
  1679.  g.export(d,type,diff);
  1680.  System.out.println(new Date()+" operation ended");
  1681. }
  1682.  
  1683. final public void dirimport(String d)
  1684. {
  1685.  repair.quiet=true;
  1686.  repair.nosave=true;
  1687.  repair.force=false;
  1688.  System.out.println(new Date()+" importing "+d);
  1689.  garbage g=new garbage(cache_dir);
  1690.  g.dirimport(d);
  1691.  System.out.println(new Date()+" operation ended");
  1692. }
  1693. final public void fake_garbage_collection()
  1694. {
  1695.  System.out.println(new Date()+" [FAKE] running garbage collection.");
  1696.  garbage g=new garbage(cache_dir);
  1697.  g.fake_garbage_collection();
  1698.  System.out.println(new Date()+" [FAKE] garbage collection ended.");
  1699. }
  1700.  
  1701. final public void kill_unref()
  1702. {
  1703.  System.out.println(new Date()+" killing unreferenced files.");
  1704.  garbage g=new garbage(cache_dir);
  1705.  g.cleanup();
  1706.  System.out.println(new Date()+" unreferenced files removed.");
  1707. }
  1708.  
  1709. final public void converto020()
  1710. {
  1711.  System.out.println(new Date()+" converting cache control files to version 0.20");
  1712.  garbage g=new garbage(cache_dir);
  1713.  g.converto020();
  1714.  System.out.println(new Date()+" operation ended\nDO *** NOT *** RUN THIS OPERATION AGAIN OR YOUR DATA IN CACHE WILL BE DESTROYED!");
  1715. }
  1716.  
  1717. final public void converto030()
  1718. {
  1719.  System.out.println(new Date()+" converting cache control files to version 0.30.");
  1720.  garbage g=new garbage(cache_dir);
  1721.  g.converto030();
  1722.  System.out.println(new Date()+" operation ended.");
  1723. }
  1724.  
  1725.  
  1726. final static private boolean is_wild(String r)
  1727. {
  1728.  if(r.indexOf('*',0)==-1) return false;
  1729.   else
  1730.    return true;
  1731. }
  1732.  
  1733. final static private boolean checkFlag(String f)
  1734. {
  1735.  if(f==null) return false;
  1736.  File fl=new File(f);
  1737.  if(fl.canRead()) 
  1738.     {fl.delete();return true;}
  1739.  return false;
  1740. }
  1741.  
  1742. final static regexp[] parseRegexpFile(String fname,regexp fail[])
  1743. {
  1744.  try
  1745.  {
  1746.  String line,token;
  1747.  StringTokenizer st;
  1748.  if(! new File(fname).isAbsolute()) fname=scache.cfgdir+File.separator+fname;
  1749.   
  1750.  DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream(fname))); 
  1751.  while ( (line = dis.readLine()) != null)
  1752.  {
  1753.       if(line.startsWith("#")) continue;
  1754.       st=new StringTokenizer(line);
  1755.       if(st.hasMoreTokens()==false) continue;
  1756.       token=st.nextToken();
  1757.       if(token.equalsIgnoreCase("fail")||token.equalsIgnoreCase("pass"))
  1758.        {
  1759.         System.out.println(new Date()+" [WARNING] Stop using Fail/Pass keyword in fail/pass file.");
  1760.         if(st.hasMoreTokens()==false) continue;
  1761.         token=st.nextToken();
  1762.        }
  1763.        if(token.indexOf('*')==-1) token+="*";
  1764.  
  1765.        fail=addRegexpToArray(token,fail);
  1766.  }
  1767.  dis.close();
  1768.  
  1769.  }
  1770.  catch (IOException ioe)
  1771.   {
  1772.    System.out.println(new Date()+" I/O Error reading file "+fname);
  1773.   }
  1774.  return fail;
  1775. }
  1776.  
  1777. /* load block c00kie */
  1778.  
  1779. final static String[] parseCookieFile(String fname,String fail[])
  1780. {
  1781.  try
  1782.  {
  1783.  String line,token;
  1784.  StringTokenizer st;
  1785.  if(! new File(fname).isAbsolute()) fname=scache.cfgdir+File.separator+fname;
  1786.  
  1787.  DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream(fname))); 
  1788.  while ( (line = dis.readLine()) != null)
  1789.  {
  1790.       if(line.startsWith("#")) continue;
  1791.       st=new StringTokenizer(line);
  1792.       while(st.hasMoreTokens())
  1793.       {
  1794.         token=st.nextToken().toLowerCase();
  1795.         
  1796.         if(token.indexOf('*')>-1) 
  1797.          {
  1798.           System.out.println(new Date()+" [ERROR] Wildcards records are not supported in cookie_file");
  1799.           continue;
  1800.          } 
  1801.         else
  1802.          if(token.equalsIgnoreCase("all")) { return null;}
  1803.         fail=addStringToArray(token,fail);
  1804.         
  1805.       }
  1806.  }
  1807.  dis.close();
  1808.  
  1809.  }
  1810.  catch (IOException ioe)
  1811.   {
  1812.    System.out.println(new Date()+" I/O Error reading file "+fname);
  1813.   }
  1814.  return fail;
  1815. }
  1816.  
  1817. final static InetAddress[] addInetAdrToArray(InetAddress what,InetAddress[] array)
  1818. {
  1819.    if(array==null) { array=new InetAddress[1];array[0]=what;return array;}
  1820.    InetAddress[] tmp;
  1821.    int ar=array.length;
  1822.    tmp=new InetAddress[ar+1];
  1823.    System.arraycopy(array,0,tmp,0,ar);
  1824.    tmp[ar]=what;
  1825.    return tmp;
  1826. }
  1827.  
  1828. } /* class */
  1829.