JspSmart之upload组件源码

   1  File.java
   2 
   3  import  java.io.ByteArrayInputStream;
   4  import  java.io.FileOutputStream;
   5  import  java.io.IOException;
   6  import  java.math.BigInteger;
   7  import  java.sql.ResultSet;
   8  import  java.sql.SQLException;
   9  import  javax.servlet.ServletException;
  10 
  11  //  Referenced classes of package com.jspsmart.upload:
  12  //  SmartUploadException, SmartUpload
  13 
  14  public   class  File
  15  {
  16 
  17  private  SmartUpload m_parent;
  18  private   int  m_startData;
  19  private   int  m_endData;
  20  private   int  m_size;
  21  private  String m_fieldname;
  22  private  String m_filename;
  23  private  String m_fileExt;
  24  private  String m_filePathName;
  25  private  String m_contentType;
  26  private  String m_contentDisp;
  27  private  String m_typeMime;
  28  private  String m_subTypeMime;
  29  private  String m_contentString;
  30  private   boolean  m_isMissing;
  31  public   static   final   int  SAVEAS_AUTO  =   0 ;
  32  public   static   final   int  SAVEAS_VIRTUAL  =   1 ;
  33  public   static   final   int  SAVEAS_PHYSICAL  =   2 ;
  34 
  35  File()
  36  {
  37  m_startData  =   0 ;
  38  m_endData  =   0 ;
  39  m_size  =   0 ;
  40  m_fieldname  =   new  String();
  41  m_filename  =   new  String();
  42  m_fileExt  =   new  String();
  43  m_filePathName  =   new  String();
  44  m_contentType  =   new  String();
  45  m_contentDisp  =   new  String();
  46  m_typeMime  =   new  String();
  47  m_subTypeMime  =   new  String();
  48  m_contentString  =   new  String();
  49  m_isMissing  =   true ;
  50  }
  51 
  52  public   void  saveAs(String s)
  53  throws  IOException, SmartUploadException
  54  {
  55  saveAs(s,  0 );
  56  }
  57 
  58  public   void  saveAs(String s,  int  i)
  59  throws  IOException, SmartUploadException
  60  {
  61  String s1  =   new  String();
  62  s1  =  m_parent.getPhysicalPath(s, i);
  63  if (s1  ==   null )
  64  throw   new  IllegalArgumentException( " There is no specified destination file (1140). " );
  65  try
  66  {
  67  java.io.File file  =   new  java.io.File(s1);
  68  FileOutputStream fileoutputstream  =   new  FileOutputStream(file);
  69  fileoutputstream.write(m_parent.m_binArray, m_startData, m_size);
  70  fileoutputstream.close();
  71  }
  72  catch (IOException ioexception)
  73  {
  74  throw   new  SmartUploadException( " File can't be saved (1120). " );
  75  }
  76  }
  77 
  78  public   void  fileToField(ResultSet resultset, String s)
  79  throws  ServletException, IOException, SmartUploadException, SQLException
  80  {
  81  long  l  =   0L ;
  82  int  i  =   0x10000 ;
  83  int  j  =   0 ;
  84  int  k  =  m_startData;
  85  if (resultset  ==   null )
  86  throw   new  IllegalArgumentException( " The RecordSet cannot be null (1145). " );
  87  if (s  ==   null )
  88  throw   new  IllegalArgumentException( " The columnName cannot be null (1150). " );
  89  if (s.length()  ==   0 )
  90  throw   new  IllegalArgumentException( " The columnName cannot be empty (1155). " );
  91  l  =  BigInteger.valueOf(m_size).divide(BigInteger.valueOf(i)).longValue();
  92  j  =  BigInteger.valueOf(m_size).mod(BigInteger.valueOf(i)).intValue();
  93  try
  94  {
  95  for ( int  i1  =   1 ; ( long )i1  <  l; i1 ++ )
  96  {
  97  resultset.updateBinaryStream(s,  new  ByteArrayInputStream(m_parent.m_binArray, k, i), i);
  98  k  =  k  !=   0   ?  k :  1 ;
  99  k  =  i1  *  i  +  m_startData;
 100  }
 101 
 102  if (j  >   0 )
 103  resultset.updateBinaryStream(s,  new  ByteArrayInputStream(m_parent.m_binArray, k, j), j);
 104  }
 105  catch (SQLException sqlexception)
 106  {
 107  byte  abyte0[]  =   new   byte [m_size];
 108  System.arraycopy(m_parent.m_binArray, m_startData, abyte0,  0 , m_size);
 109  resultset.updateBytes(s, abyte0);
 110  }
 111  catch (Exception exception)
 112  {
 113  throw   new  SmartUploadException( " Unable to save file in the DataBase (1130). " );
 114  }
 115  }
 116 
 117  public   boolean  isMissing()
 118  {
 119  return  m_isMissing;
 120  }
 121 
 122  public  String getFieldName()
 123  {
 124  return  m_fieldname;
 125  }
 126 
 127  public  String getFileName()
 128  {
 129  return  m_filename;
 130  }
 131 
 132  public  String getFilePathName()
 133  {
 134  return  m_filePathName;
 135  }
 136 
 137  public  String getFileExt()
 138  {
 139  return  m_fileExt;
 140  }
 141 
 142  public  String getContentType()
 143  {
 144  return  m_contentType;
 145  }
 146 
 147  public  String getContentDisp()
 148  {
 149  return  m_contentDisp;
 150  }
 151 
 152  public  String getContentString()
 153  {
 154  String s  =   new  String(m_parent.m_binArray, m_startData, m_size);
 155  return  s;
 156  }
 157 
 158  public  String getTypeMIME()
 159  throws  IOException
 160  {
 161  return  m_typeMime;
 162  }
 163 
 164  public  String getSubTypeMIME()
 165  {
 166  return  m_subTypeMime;
 167  }
 168 
 169  public   int  getSize()
 170  {
 171  return  m_size;
 172  }
 173 
 174  protected   int  getStartData()
 175  {
 176  return  m_startData;
 177  }
 178 
 179  protected   int  getEndData()
 180  {
 181  return  m_endData;
 182  }
 183 
 184  protected   void  setParent(SmartUpload smartupload)
 185  {
 186  m_parent  =  smartupload;
 187  }
 188 
 189  protected   void  setStartData( int  i)
 190  {
 191  m_startData  =  i;
 192  }
 193 
 194  protected   void  setEndData( int  i)
 195  {
 196  m_endData  =  i;
 197  }
 198 
 199  protected   void  setSize( int  i)
 200  {
 201  m_size  =  i;
 202  }
 203 
 204  protected   void  setIsMissing( boolean  flag)
 205  {
 206  m_isMissing  =  flag;
 207  }
 208 
 209  protected   void  setFieldName(String s)
 210  {
 211  m_fieldname  =  s;
 212  }
 213 
 214  protected   void  setFileName(String s)
 215  {
 216  m_filename  =  s;
 217  }
 218 
 219  protected   void  setFilePathName(String s)
 220  {
 221  m_filePathName  =  s;
 222  }
 223 
 224  protected   void  setFileExt(String s)
 225  {
 226  m_fileExt  =  s;
 227  }
 228 
 229  protected   void  setContentType(String s)
 230  {
 231  m_contentType  =  s;
 232  }
 233 
 234  protected   void  setContentDisp(String s)
 235  {
 236  m_contentDisp  =  s;
 237  }
 238 
 239  protected   void  setTypeMIME(String s)
 240  {
 241  m_typeMime  =  s;
 242  }
 243 
 244  protected   void  setSubTypeMIME(String s)
 245  {
 246  m_subTypeMime  =  s;
 247  }
 248 
 249  public   byte  getBinaryData( int  i)
 250  {
 251  if (m_startData  +  i  >  m_endData)
 252  throw   new  ArrayIndexOutOfBoundsException( " Index Out of range (1115). " );
 253  if (m_startData  +  i  <=  m_endData)
 254  return  m_parent.m_binArray[m_startData  +  i];
 255  else
 256  return   0 ;
 257  }
 258  }
 259 
 260 
 261  Files.java
 262 
 263  import  java.io.IOException;
 264  import  java.util. * ;
 265 
 266  //  Referenced classes of package com.jspsmart.upload:
 267  //  File, SmartUpload
 268 
 269  public   class  Files
 270  {
 271 
 272  private  SmartUpload m_parent;
 273  private  Hashtable m_files;
 274  private   int  m_counter;
 275 
 276  Files()
 277  {
 278  m_files  =   new  Hashtable();
 279  m_counter  =   0 ;
 280  }
 281 
 282  protected   void  addFile(File file)
 283  {
 284  if (file  ==   null )
 285  {
 286  throw   new  IllegalArgumentException( " newFile cannot be null. " );
 287  }  else
 288  {
 289  m_files.put( new  Integer(m_counter), file);
 290  m_counter ++ ;
 291  return ;
 292  }
 293  }
 294 
 295  public  File getFile( int  i)
 296  {
 297  if (i  <   0 )
 298  throw   new  IllegalArgumentException( " File's index cannot be a negative value (1210). " );
 299  File file  =  (File)m_files.get( new  Integer(i));
 300  if (file  ==   null )
 301  throw   new  IllegalArgumentException( " Files' name is invalid or does not exist (1205). " );
 302  else
 303  return  file;
 304  }
 305 
 306  public   int  getCount()
 307  {
 308  return  m_counter;
 309  }
 310 
 311  public   long  getSize()
 312  throws  IOException
 313  {
 314  long  l  =   0L ;
 315  for ( int  i  =   0 ; i  <  m_counter; i ++ )
 316  l  +=  getFile(i).getSize();
 317 
 318  return  l;
 319  }
 320 
 321  public  Collection getCollection()
 322  {
 323  return  m_files.values();
 324  }
 325 
 326  public  Enumeration getEnumeration()
 327  {
 328  return  m_files.elements();
 329  }
 330  }
 331 
 332 
 333  Request.java
 334 
 335  import  java.util.Enumeration;
 336  import  java.util.Hashtable;
 337 
 338  public   class  Request
 339  {
 340 
 341  private  Hashtable m_parameters;
 342  private   int  m_counter;
 343 
 344  Request()
 345  {
 346  m_parameters  =   new  Hashtable();
 347  m_counter  =   0 ;
 348  }
 349 
 350  protected   void  putParameter(String s, String s1)
 351  {
 352  if (s  ==   null )
 353  throw   new  IllegalArgumentException( " The name of an element cannot be null. " );
 354  if (m_parameters.containsKey(s))
 355  {
 356  Hashtable hashtable  =  (Hashtable)m_parameters.get(s);
 357  hashtable.put( new  Integer(hashtable.size()), s1);
 358  }  else
 359  {
 360  Hashtable hashtable1  =   new  Hashtable();
 361  hashtable1.put( new  Integer( 0 ), s1);
 362  m_parameters.put(s, hashtable1);
 363  m_counter ++ ;
 364  }
 365  }
 366 
 367  public  String getParameter(String s)
 368  {
 369  if (s  ==   null )
 370  throw   new  IllegalArgumentException( " Form's name is invalid or does not exist (1305). " );
 371  Hashtable hashtable  =  (Hashtable)m_parameters.get(s);
 372  if (hashtable  ==   null )
 373  return   null ;
 374  else
 375  return  (String)hashtable.get( new  Integer( 0 ));
 376  }
 377 
 378  public  Enumeration getParameterNames()
 379  {
 380  return  m_parameters.keys();
 381  }
 382 
 383  public  String[] getParameterValues(String s)
 384  {
 385  if (s  ==   null )
 386  throw   new  IllegalArgumentException( " Form's name is invalid or does not exist (1305). " );
 387  Hashtable hashtable  =  (Hashtable)m_parameters.get(s);
 388  if (hashtable  ==   null )
 389  return   null ;
 390  String as[]  =   new  String[hashtable.size()];
 391  for ( int  i  =   0 ; i  <  hashtable.size(); i ++ )
 392  as[i]  =  (String)hashtable.get( new  Integer(i));
 393 
 394  return  as;
 395  }
 396  }
 397 
 398 
 399  SmartUploadException .java
 400 
 401  public   class  SmartUploadException  extends  Exception
 402  {
 403 
 404  SmartUploadException(String s)
 405  {
 406  super (s);
 407  }
 408  }
 409 
 410 
 411  SmartUpload.java
 412 
 413  import  java.io. * ;
 414  import  java.sql.ResultSet;
 415  import  java.sql.SQLException;
 416  import  java.util.Vector;
 417  import  javax.servlet. * ;
 418  import  javax.servlet.http. * ;
 419  import  javax.servlet.jsp.JspWriter;
 420  import  javax.servlet.jsp.PageContext;
 421 
 422  //  Referenced classes of package com.jspsmart.upload:
 423  //  Files, Request, SmartUploadException, File
 424 
 425  public   class  SmartUpload
 426  {
 427 
 428  protected   byte  m_binArray[];
 429  protected  HttpServletRequest m_request;
 430  protected  HttpServletResponse m_response;
 431  protected  ServletContext m_application;
 432  private   int  m_totalBytes;
 433  private   int  m_currentIndex;
 434  private   int  m_startData;
 435  private   int  m_endData;
 436  private  String m_boundary;
 437  private   long  m_totalMaxFileSize;
 438  private   long  m_maxFileSize;
 439  private  Vector m_deniedFilesList;
 440  private  Vector m_allowedFilesList;
 441  private   boolean  m_denyPhysicalPath;
 442  private   boolean  m_forcePhysicalPath;
 443  private  String m_contentDisposition;
 444  public   static   final   int  SAVE_AUTO  =   0 ;
 445  public   static   final   int  SAVE_VIRTUAL  =   1 ;
 446  public   static   final   int  SAVE_PHYSICAL  =   2 ;
 447  private  Files m_files;
 448  private  Request m_formRequest;
 449 
 450  public  SmartUpload()
 451  {
 452  m_totalBytes  =   0 ;
 453  m_currentIndex  =   0 ;
 454  m_startData  =   0 ;
 455  m_endData  =   0 ;
 456  m_boundary  =   new  String();
 457  m_totalMaxFileSize  =   0L ;
 458  m_maxFileSize  =   0L ;
 459  m_deniedFilesList  =   new  Vector();
 460  m_allowedFilesList  =   new  Vector();
 461  m_denyPhysicalPath  =   false ;
 462  m_forcePhysicalPath  =   false ;
 463  m_contentDisposition  =   new  String();
 464  m_files  =   new  Files();
 465  m_formRequest  =   new  Request();
 466  }
 467 
 468  public   final   void  init(ServletConfig servletconfig)
 469  throws  ServletException
 470  {
 471  m_application  =  servletconfig.getServletContext();
 472  }
 473 
 474  public   void  service(HttpServletRequest httpservletrequest, HttpServletResponse httpservletresponse)
 475  throws  ServletException, IOException
 476  {
 477  m_request  =  httpservletrequest;
 478  m_response  =  httpservletresponse;
 479  }
 480 
 481  public   final   void  initialize(ServletConfig servletconfig, HttpServletRequest httpservletrequest, HttpServletResponse httpservletresponse)
 482  throws  ServletException
 483  {
 484  m_application  =  servletconfig.getServletContext();
 485  m_request  =  httpservletrequest;
 486  m_response  =  httpservletresponse;
 487  }
 488 
 489  public   final   void  initialize(PageContext pagecontext)
 490  throws  ServletException
 491  {
 492  m_application  =  pagecontext.getServletContext();
 493  m_request  =  (HttpServletRequest)pagecontext.getRequest();
 494  m_response  =  (HttpServletResponse)pagecontext.getResponse();
 495  }
 496 
 497  public   final   void  initialize(ServletContext servletcontext, HttpSession httpsession, HttpServletRequest httpservletrequest, HttpServletResponse httpservletresponse, JspWriter jspwriter)
 498  throws  ServletException
 499  {
 500  m_application  =  servletcontext;
 501  m_request  =  httpservletrequest;
 502  m_response  =  httpservletresponse;
 503  }
 504 
 505  public   void  upload()
 506  throws  ServletException, IOException, SmartUploadException
 507  {
 508  int  i  =   0 ;
 509  boolean  flag  =   false ;
 510  long  l  =   0L ;
 511  boolean  flag1  =   false ;
 512  String s  =   new  String();
 513  String s2  =   new  String();
 514  String s4  =   new  String();
 515  String s5  =   new  String();
 516  String s6  =   new  String();
 517  String s7  =   new  String();
 518  String s8  =   new  String();
 519  String s9  =   new  String();
 520  String s10  =   new  String();
 521  boolean  flag2  =   false ;
 522  m_totalBytes  =  m_request.getContentLength();
 523  m_binArray  =   new   byte [m_totalBytes];
 524  int  j;
 525  for (; i  <  m_totalBytes; i  +=  j)
 526  try
 527  {
 528  m_request.getInputStream();
 529  j  =  m_request.getInputStream().read(m_binArray, i, m_totalBytes  -  i);
 530  }
 531  catch (Exception exception)
 532  {
 533  throw   new  SmartUploadException( " Unable to upload. " );
 534  }
 535 
 536  for (;  ! flag1  &&  m_currentIndex  <  m_totalBytes; m_currentIndex ++ )
 537  if (m_binArray[m_currentIndex]  ==   13 )
 538  flag1  =   true ;
 539  else
 540  m_boundary  =  m_boundary  +  ( char )m_binArray[m_currentIndex];
 541 
 542  if (m_currentIndex  ==   1 )
 543  return ;
 544  for (m_currentIndex ++ ; m_currentIndex  <  m_totalBytes; m_currentIndex  =  m_currentIndex  +   2 )
 545  {
 546  String s1  =  getDataHeader();
 547  m_currentIndex  =  m_currentIndex  +   2 ;
 548  boolean  flag3  =  s1.indexOf( " filename " )  >   0 ;
 549  String s3  =  getDataFieldValue(s1,  " name " );
 550  if (flag3)
 551  {
 552  s6  =  getDataFieldValue(s1,  " filename " );
 553  s4  =  getFileName(s6);
 554  s5  =  getFileExt(s4);
 555  s7  =  getContentType(s1);
 556  s8  =  getContentDisp(s1);
 557  s9  =  getTypeMIME(s7);
 558  s10  =  getSubTypeMIME(s7);
 559  }
 560  getDataSection();
 561  if (flag3  &&  s4.length()  >   0 )
 562  {
 563  if (m_deniedFilesList.contains(s5))
 564  throw   new  SecurityException( " The extension of the file is denied to be uploaded (1015). " );
 565  if ( ! m_allowedFilesList.isEmpty()  &&   ! m_allowedFilesList.contains(s5))
 566  throw   new  SecurityException( " The extension of the file is not allowed to be uploaded (1010). " );
 567  if (m_maxFileSize  >   0L   &&  ( long )((m_endData  -  m_startData)  +   1 )  >  m_maxFileSize)
 568  throw   new  SecurityException( " Size exceeded for this file :  "   +  s4  +   "  (1105). " );
 569  l  +=  (m_endData  -  m_startData)  +   1 ;
 570  if (m_totalMaxFileSize  >   0L   &&  l  >  m_totalMaxFileSize)
 571  throw   new  SecurityException( " Total File Size exceeded (1110). " );
 572  }
 573  if (flag3)
 574  {
 575  com.facet.jspsmart.upload.File file  =   new  com.facet.jspsmart.upload.File();
 576  file.setParent( this );
 577  file.setFieldName(s3);
 578  file.setFileName(s4);
 579  file.setFileExt(s5);
 580  file.setFilePathName(s6);
 581  file.setIsMissing(s6.length()  ==   0 );
 582  file.setContentType(s7);
 583  file.setContentDisp(s8);
 584  file.setTypeMIME(s9);
 585  file.setSubTypeMIME(s10);
 586  if (s7.indexOf( " application/x-macbinary " )  >   0 )
 587  m_startData  =  m_startData  +   128 ;
 588  file.setSize((m_endData  -  m_startData)  +   1 );
 589  file.setStartData(m_startData);
 590  file.setEndData(m_endData);
 591  m_files.addFile(file);
 592  }  else
 593  {
 594  String s11  =   new  String(m_binArray, m_startData, (m_endData  -  m_startData)  +   1 );
 595  m_formRequest.putParameter(s3, s11);
 596  }
 597  if (( char )m_binArray[m_currentIndex  +   1 ]  ==   ' - ' )
 598  break ;
 599  }
 600 
 601  }
 602 
 603  public   int  save(String s)
 604  throws  ServletException, IOException, SmartUploadException
 605  {
 606  return  save(s,  0 );
 607  }
 608 
 609  public   int  save(String s,  int  i)
 610  throws  ServletException, IOException, SmartUploadException
 611  {
 612  int  j  =   0 ;
 613  if (s  ==   null )
 614  s  =  m_application.getRealPath( " / " );
 615  if (s.indexOf( " / " )  !=   - 1 )
 616  {
 617  if (s.charAt(s.length()  -   1 )  !=   ' / ' )
 618  s  =  s  +   " / " ;
 619  }  else
 620  if (s.charAt(s.length()  -   1 )  !=   ' \\ ' )
 621  s  =  s  +   " \\ " ;
 622  for ( int  k  =   0 ; k  <  m_files.getCount(); k ++ )
 623  if ( ! m_files.getFile(k).isMissing())
 624  {
 625  m_files.getFile(k).saveAs(s  +  m_files.getFile(k).getFileName(), i);
 626  j ++ ;
 627  }
 628 
 629  return  j;
 630  }
 631 
 632  public   int  getSize()
 633  {
 634  return  m_totalBytes;
 635  }
 636 
 637  public   byte  getBinaryData( int  i)
 638  {
 639  byte  byte0;
 640  try
 641  {
 642  byte0  =  m_binArray[i];
 643  }
 644  catch (Exception exception)
 645  {
 646  throw   new  ArrayIndexOutOfBoundsException( " Index out of range (1005). " );
 647  }
 648  return  byte0;
 649  }
 650 
 651  public  Files getFiles()
 652  {
 653  return  m_files;
 654  }
 655 
 656  public  Request getRequest()
 657  {
 658  return  m_formRequest;
 659  }
 660 
 661  public   void  downloadFile(String s)
 662  throws  ServletException, IOException, SmartUploadException
 663  {
 664  downloadFile(s,  null ,  null );
 665  }
 666 
 667  public   void  downloadFile(String s, String s1)
 668  throws  ServletException, IOException, SmartUploadException, SmartUploadException
 669  {
 670  downloadFile(s, s1,  null );
 671  }
 672 
 673  public   void  downloadFile(String s, String s1, String s2)
 674  throws  ServletException, IOException, SmartUploadException
 675  {
 676  downloadFile(s, s1, s2,  65000 );
 677  }
 678 
 679  public   void  downloadFile(String s, String s1, String s2,  int  i)
 680  throws  ServletException, IOException, SmartUploadException
 681  {
 682  if (s  ==   null )
 683  throw   new  IllegalArgumentException( " File ' "   +  s  +   " ' not found (1040). " );
 684  if (s.equals( "" ))
 685  throw   new  IllegalArgumentException( " File ' "   +  s  +   " ' not found (1040). " );
 686  if ( ! isVirtual(s)  &&  m_denyPhysicalPath)
 687  throw   new  SecurityException( " Physical path is denied (1035). " );
 688  if (isVirtual(s))
 689  s  =  m_application.getRealPath(s);
 690  java.io.File file  =   new  java.io.File(s);
 691  FileInputStream fileinputstream  =   new  FileInputStream(file);
 692  long  l  =  file.length();
 693  boolean  flag  =   false ;
 694  int  k  =   0 ;
 695  byte  abyte0[]  =   new   byte [i];
 696  if (s1  ==   null )
 697  m_response.setContentType( " application/x-msdownload " );
 698  else
 699  if (s1.length()  ==   0 )
 700  m_response.setContentType( " application/x-msdownload " );
 701  else
 702  m_response.setContentType(s1);
 703  m_response.setContentLength(( int )l);
 704  m_contentDisposition  =  m_contentDisposition  !=   null   ?  m_contentDisposition :  " attachment; " ;
 705  if (s2  ==   null )
 706  m_response.setHeader( " Content-Disposition " , m_contentDisposition  +   "  filename= "   +  getFileName(s));
 707  else
 708  if (s2.length()  ==   0 )
 709  m_response.setHeader( " Content-Disposition " , m_contentDisposition);
 710  else
 711  m_response.setHeader( " Content-Disposition " , m_contentDisposition  +   "  filename= "   +  s2);
 712  while (( long )k  <  l)
 713  {
 714  int  j  =  fileinputstream.read(abyte0,  0 , i);
 715  k  +=  j;
 716  m_response.getOutputStream().write(abyte0,  0 , j);
 717  }
 718  fileinputstream.close();
 719  }
 720 
 721  public   void  downloadField(ResultSet resultset, String s, String s1, String s2)
 722  throws  ServletException, IOException, SQLException
 723  {
 724  if (resultset  ==   null )
 725  throw   new  IllegalArgumentException( " The RecordSet cannot be null (1045). " );
 726  if (s  ==   null )
 727  throw   new  IllegalArgumentException( " The columnName cannot be null (1050). " );
 728  if (s.length()  ==   0 )
 729  throw   new  IllegalArgumentException( " The columnName cannot be empty (1055). " );
 730  byte  abyte0[]  =  resultset.getBytes(s);
 731  if (s1  ==   null )
 732  m_response.setContentType( " application/x-msdownload " );
 733  else
 734  if (s1.length()  ==   0 )
 735  m_response.setContentType( " application/x-msdownload " );
 736  else
 737  m_response.setContentType(s1);
 738  m_response.setContentLength(abyte0.length);
 739  if (s2  ==   null )
 740  m_response.setHeader( " Content-Disposition " ,  " attachment; " );
 741  else
 742  if (s2.length()  ==   0 )
 743  m_response.setHeader( " Content-Disposition " ,  " attachment; " );
 744  else
 745  m_response.setHeader( " Content-Disposition " ,  " attachment; filename= "   +  s2);
 746  m_response.getOutputStream().write(abyte0,  0 , abyte0.length);
 747  }
 748 
 749  public   void  fieldToFile(ResultSet resultset, String s, String s1)
 750  throws  ServletException, IOException, SmartUploadException, SQLException
 751  {
 752  try
 753  {
 754  if (m_application.getRealPath(s1)  !=   null )
 755  s1  =  m_application.getRealPath(s1);
 756  InputStream inputstream  =  resultset.getBinaryStream(s);
 757  FileOutputStream fileoutputstream  =   new  FileOutputStream(s1);
 758  int  i;
 759  while ((i  =  inputstream.read())  !=   - 1 )
 760  fileoutputstream.write(i);
 761  fileoutputstream.close();
 762  }
 763  catch (Exception exception)
 764  {
 765  throw   new  SmartUploadException( " Unable to save file from the DataBase (1020). " );
 766  }
 767  }
 768 
 769  private  String getDataFieldValue(String s, String s1)
 770  {
 771  String s2  =   new  String();
 772  String s3  =   new  String();
 773  int  i  =   0 ;
 774  boolean  flag  =   false ;
 775  boolean  flag1  =   false ;
 776  boolean  flag2  =   false ;
 777  s2  =  s1  +   " = "   +   ' " ' ;
 778  i  =  s.indexOf(s2);
 779  if (i  >   0 )
 780  {
 781  int  j  =  i  +  s2.length();
 782  int  k  =  j;
 783  s2  =   " \ "" ;
 784  int  l  =  s.indexOf(s2, j);
 785  if (k  >   0   &&  l  >   0 )
 786  s3  =  s.substring(k, l);
 787  }
 788  return  s3;
 789  }
 790 
 791  private  String getFileExt(String s)
 792  {
 793  String s1  =   new  String();
 794  int  i  =   0 ;
 795  int  j  =   0 ;
 796  if (s  ==   null )
 797  return   null ;
 798  i  =  s.lastIndexOf( 46 )  +   1 ;
 799  j  =  s.length();
 800  s1  =  s.substring(i, j);
 801  if (s.lastIndexOf( 46 )  >   0 )
 802  return  s1;
 803  else
 804  return   "" ;
 805  }
 806 
 807  private  String getContentType(String s)
 808  {
 809  String s1  =   new  String();
 810  String s2  =   new  String();
 811  int  i  =   0 ;
 812  boolean  flag  =   false ;
 813  s1  =   " Content-Type: " ;
 814  i  =  s.indexOf(s1)  +  s1.length();
 815  if (i  !=   - 1 )
 816  {
 817  int  j  =  s.length();
 818  s2  =  s.substring(i, j);
 819  }
 820  return  s2;
 821  }
 822 
 823  private  String getTypeMIME(String s)
 824  {
 825  String s1  =   new  String();
 826  int  i  =   0 ;
 827  i  =  s.indexOf( " / " );
 828  if (i  !=   - 1 )
 829  return  s.substring( 1 , i);
 830  else
 831  return  s;
 832  }
 833 
 834  private  String getSubTypeMIME(String s)
 835  {
 836  String s1  =   new  String();
 837  int  i  =   0 ;
 838  boolean  flag  =   false ;
 839  i  =  s.indexOf( " / " )  +   1 ;
 840  if (i  !=   - 1 )
 841  {
 842  int  j  =  s.length();
 843  return  s.substring(i, j);
 844  }  else
 845  {
 846  return  s;
 847  }
 848  }
 849 
 850  private  String getContentDisp(String s)
 851  {
 852  String s1  =   new  String();
 853  int  i  =   0 ;
 854  int  j  =   0 ;
 855  i  =  s.indexOf( " : " )  +   1 ;
 856  j  =  s.indexOf( " ; " );
 857  s1  =  s.substring(i, j);
 858  return  s1;
 859  }
 860 
 861  private   void  getDataSection()
 862  {
 863  boolean  flag  =   false ;
 864  String s  =   new  String();
 865  int  i  =  m_currentIndex;
 866  int  j  =   0 ;
 867  int  k  =  m_boundary.length();
 868  m_startData  =  m_currentIndex;
 869  m_endData  =   0 ;
 870  while (i  <  m_totalBytes)
 871  if (m_binArray[i]  ==  ( byte )m_boundary.charAt(j))
 872  {
 873  if (j  ==  k  -   1 )
 874  {
 875  m_endData  =  ((i  -  k)  +   1 )  -   3 ;
 876  break ;
 877  }
 878  i ++ ;
 879  j ++ ;
 880  }  else
 881  {
 882  i ++ ;
 883  j  =   0 ;
 884  }
 885  m_currentIndex  =  m_endData  +  k  +   3 ;
 886  }
 887 
 888  private  String getDataHeader()
 889  {
 890  int  i  =  m_currentIndex;
 891  int  j  =   0 ;
 892  boolean  flag  =   false ;
 893  for ( boolean  flag1  =   false ;  ! flag1;)
 894  if (m_binArray[m_currentIndex]  ==   13   &&  m_binArray[m_currentIndex  +   2 ]  ==   13 )
 895  {
 896  flag1  =   true ;
 897  j  =  m_currentIndex  -   1 ;
 898  m_currentIndex  =  m_currentIndex  +   2 ;
 899  }  else
 900  {
 901  m_currentIndex ++ ;
 902  }
 903 
 904  String s  =   new  String(m_binArray, i, (j  -  i)  +   1 );
 905  return  s;
 906  }
 907 
 908  private  String getFileName(String s)
 909  {
 910  String s1  =   new  String();
 911  String s2  =   new  String();
 912  int  i  =   0 ;
 913  boolean  flag  =   false ;
 914  boolean  flag1  =   false ;
 915  boolean  flag2  =   false ;
 916  i  =  s.lastIndexOf( 47 );
 917  if (i  !=   - 1 )
 918  return  s.substring(i  +   1 , s.length());
 919  i  =  s.lastIndexOf( 92 );
 920  if (i  !=   - 1 )
 921  return  s.substring(i  +   1 , s.length());
 922  else
 923  return  s;
 924  }
 925 
 926  public   void  setDeniedFilesList(String s)
 927  throws  ServletException, IOException, SQLException
 928  {
 929  String s1  =   "" ;
 930  if (s  !=   null )
 931  {
 932  String s2  =   "" ;
 933  for ( int  i  =   0 ; i  <  s.length(); i ++ )
 934  if (s.charAt(i)  ==   ' , ' )
 935  {
 936  if ( ! m_deniedFilesList.contains(s2))
 937  m_deniedFilesList.addElement(s2);
 938  s2  =   "" ;
 939  }  else
 940  {
 941  s2  =  s2  +  s.charAt(i);
 942  }
 943 
 944  if (s2  !=   "" )
 945  m_deniedFilesList.addElement(s2);
 946  }  else
 947  {
 948  m_deniedFilesList  =   null ;
 949  }
 950  }
 951 
 952  public   void  setAllowedFilesList(String s)
 953  {
 954  String s1  =   "" ;
 955  if (s  !=   null )
 956  {
 957  String s2  =   "" ;
 958  for ( int  i  =   0 ; i  <  s.length(); i ++ )
 959  if (s.charAt(i)  ==   ' , ' )
 960  {
 961  if ( ! m_allowedFilesList.contains(s2))
 962  m_allowedFilesList.addElement(s2);
 963  s2  =   "" ;
 964  }  else
 965  {
 966  s2  =  s2  +  s.charAt(i);
 967  }
 968 
 969  if (s2  !=   "" )
 970  m_allowedFilesList.addElement(s2);
 971  }  else
 972  {
 973  m_allowedFilesList  =   null ;
 974  }
 975  }
 976 
 977  public   void  setDenyPhysicalPath( boolean  flag)
 978  {
 979  m_denyPhysicalPath  =  flag;
 980  }
 981 
 982  public   void  setForcePhysicalPath( boolean  flag)
 983  {
 984  m_forcePhysicalPath  =  flag;
 985  }
 986 
 987  public   void  setContentDisposition(String s)
 988  {
 989  m_contentDisposition  =  s;
 990  }
 991 
 992  public   void  setTotalMaxFileSize( long  l)
 993  {
 994  m_totalMaxFileSize  =  l;
 995  }
 996 
 997  public   void  setMaxFileSize( long  l)
 998  {
 999  m_maxFileSize  =  l;
1000  }
1001 
1002  protected  String getPhysicalPath(String s,  int  i)
1003  throws  IOException
1004  {
1005  String s1  =   new  String();
1006  String s2  =   new  String();
1007  String s3  =   new  String();
1008  boolean  flag  =   false ;
1009  s3  =  System.getProperty( " file.separator " );
1010  if (s  ==   null )
1011  throw   new  IllegalArgumentException( " There is no specified destination file (1140). " );
1012  if (s.equals( "" ))
1013  throw   new  IllegalArgumentException( " There is no specified destination file (1140). " );
1014  if (s.lastIndexOf( " \\ " )  >=   0 )
1015  {
1016  s1  =  s.substring( 0 , s.lastIndexOf( " \\ " ));
1017  s2  =  s.substring(s.lastIndexOf( " \\ " )  +   1 );
1018  }
1019  if (s.lastIndexOf( " / " )  >=   0 )
1020  {
1021  s1  =  s.substring( 0 , s.lastIndexOf( " / " ));
1022  s2  =  s.substring(s.lastIndexOf( " / " )  +   1 );
1023  }
1024  s1  =  s1.length()  !=   0   ?  s1 :  " / " ;
1025  java.io.File file  =   new  java.io.File(s1);
1026  if (file.exists())
1027  flag  =   true ;
1028  if (i  ==   0 )
1029  {
1030  if (isVirtual(s1))
1031  {
1032  s1  =  m_application.getRealPath(s1);
1033  if (s1.endsWith(s3))
1034  s1  =  s1  +  s2;
1035  else
1036  s1  =  s1  +  s3  +  s2;
1037  return  s1;
1038  }
1039  if (flag)
1040  {
1041  if (m_denyPhysicalPath)
1042  throw   new  IllegalArgumentException( " Physical path is denied (1125). " );
1043  else
1044  return  s;
1045  }  else
1046  {
1047  throw   new  IllegalArgumentException( " This path does not exist (1135). " );
1048  }
1049  }
1050  if (i  ==   1 )
1051  {
1052  if (isVirtual(s1))
1053  {
1054  s1  =  m_application.getRealPath(s1);
1055  if (s1.endsWith(s3))
1056  s1  =  s1  +  s2;
1057  else
1058  s1  =  s1  +  s3  +  s2;
1059  return  s1;
1060  }
1061  if (flag)
1062  throw   new  IllegalArgumentException( " The path is not a virtual path. " );
1063  else
1064  throw   new  IllegalArgumentException( " This path does not exist (1135). " );
1065  }
1066  if (i  ==   2 )
1067  {
1068  if (flag)
1069  if (m_denyPhysicalPath)
1070  throw   new  IllegalArgumentException( " Physical path is denied (1125). " );
1071  else
1072  return  s;
1073  if (isVirtual(s1))
1074  throw   new  IllegalArgumentException( " The path is not a physical path. " );
1075  else
1076  throw   new  IllegalArgumentException( " This path does not exist (1135). " );
1077  }  else
1078  {
1079  return   null ;
1080  }
1081  }
1082 
1083  public   void  uploadInFile(String s)
1084  throws  IOException, SmartUploadException
1085  {
1086  int  i  =   0 ;
1087  int  j  =   0 ;
1088  boolean  flag  =   false ;
1089  if (s  ==   null )
1090  throw   new  IllegalArgumentException( " There is no specified destination file (1025). " );
1091  if (s.length()  ==   0 )
1092  throw   new  IllegalArgumentException( " There is no specified destination file (1025). " );
1093  if ( ! isVirtual(s)  &&  m_denyPhysicalPath)
1094  throw   new  SecurityException( " Physical path is denied (1035). " );
1095  i  =  m_request.getContentLength();
1096  m_binArray  =   new   byte [i];
1097  int  k;
1098  for (; j  <  i; j  +=  k)
1099  try
1100  {
1101  k  =  m_request.getInputStream().read(m_binArray, j, i  -  j);
1102  }
1103  catch (Exception exception)
1104  {
1105  throw   new  SmartUploadException( " Unable to upload. " );
1106  }
1107 
1108  if (isVirtual(s))
1109  s  =  m_application.getRealPath(s);
1110  try
1111  {
1112  java.io.File file  =   new  java.io.File(s);
1113  FileOutputStream fileoutputstream  =   new  FileOutputStream(file);
1114  fileoutputstream.write(m_binArray);
1115  fileoutputstream.close();
1116  }
1117  catch (Exception exception1)
1118  {
1119  throw   new  SmartUploadException( " The Form cannot be saved in the specified file (1030). " );
1120  }
1121  }
1122 
1123  private   boolean  isVirtual(String s)
1124  {
1125  if (m_application.getRealPath(s)  !=   null )
1126  {
1127  java.io.File file  =   new  java.io.File(m_application.getRealPath(s));
1128  return  file.exists();
1129  }  else
1130  {
1131  return   false ;
1132  }
1133  }
1134  }