httemplate/elements/fckeditor/editor/filemanager/connectors/perl/upload_fck.pl

   1 #####\r
   2 #  FCKeditor - The text editor for Internet - http://www.fckeditor.net\r
   3 #  Copyright (C) 2003-2010 Frederico Caldeira Knabben\r
   4 #\r
   5 #  == BEGIN LICENSE ==\r
   6 #\r
   7 #  Licensed under the terms of any of the following licenses at your\r
   8 #  choice:\r
   9 #\r
  10 #   - GNU General Public License Version 2 or later (the "GPL")\r
  11 #     http://www.gnu.org/licenses/gpl.html\r
  12 #\r
  13 #   - GNU Lesser General Public License Version 2.1 or later (the "LGPL")\r
  14 #     http://www.gnu.org/licenses/lgpl.html\r
  15 #\r
  16 #   - Mozilla Public License Version 1.1 or later (the "MPL")\r
  17 #     http://www.mozilla.org/MPL/MPL-1.1.html\r
  18 #\r
  19 #  == END LICENSE ==\r
  20 #\r
  21 #  This is the File Manager Connector for Perl.\r
  22 #####\r
  23 \r
  24 # image data save dir\r
  25 $img_dir        = './temp/';\r
  26 \r
  27 \r
  28 # File size max(unit KB)\r
  29 $MAX_CONTENT_SIZE =  30000;\r
  30 \r
  31 # After file is uploaded, sometimes it is required to change its permissions\r
  32 # so that it was possible to access it at the later time.\r
  33 # If possible, it is recommended to set more restrictive permissions, like 0755.\r
  34 # Set to 0 to disable this feature.\r
  35 $CHMOD_ON_UPLOAD = 0777;\r
  36 \r
  37 # See comments above.\r
  38 # Used when creating folders that does not exist.\r
  39 $CHMOD_ON_FOLDER_CREATE = 0755;\r
  40 \r
  41 # Filelock (1=use,0=not use)\r
  42 $PM{'flock'}            = '1';\r
  43 \r
  44 \r
  45 # upload Content-Type list\r
  46 my %UPLOAD_CONTENT_TYPE_LIST = (\r
  47         'image/(x-)?png'                                                =>      'png',  # PNG image\r
  48         'image/p?jpe?g'                                                 =>      'jpg',  # JPEG image\r
  49         'image/gif'                                                             =>      'gif',  # GIF image\r
  50         'image/x-xbitmap'                                               =>      'xbm',  # XBM image\r
  51 \r
  52         'image/(x-(MS-)?)?bmp'                                  =>      'bmp',  # Windows BMP image\r
  53         'image/pict'                                                    =>      'pict', # Macintosh PICT image\r
  54         'image/tiff'                                                    =>      'tif',  # TIFF image\r
  55         'application/pdf'                                               =>      'pdf',  # PDF image\r
  56         'application/x-shockwave-flash'                 =>      'swf',  # Shockwave Flash\r
  57 \r
  58         'video/(x-)?msvideo'                                    =>      'avi',  # Microsoft Video\r
  59         'video/quicktime'                                               =>      'mov',  # QuickTime Video\r
  60         'video/mpeg'                                                    =>      'mpeg', # MPEG Video\r
  61         'video/x-mpeg2'                                                 =>      'mpv2', # MPEG2 Video\r
  62 \r
  63         'audio/(x-)?midi?'                                              =>      'mid',  # MIDI Audio\r
  64         'audio/(x-)?wav'                                                =>      'wav',  # WAV Audio\r
  65         'audio/basic'                                                   =>      'au',   # ULAW Audio\r
  66         'audio/mpeg'                                                    =>      'mpga', # MPEG Audio\r
  67 \r
  68         'application/(x-)?zip(-compressed)?'    =>      'zip',  # ZIP Compress\r
  69 \r
  70         'text/html'                                                             =>      'html', # HTML\r
  71         'text/plain'                                                    =>      'txt',  # TEXT\r
  72         '(?:application|text)/(?:rtf|richtext)' =>      'rtf',  # RichText\r
  73 \r
  74         'application/msword'                                    =>      'doc',  # Microsoft Word\r
  75         'application/vnd.ms-excel'                              =>      'xls',  # Microsoft Excel\r
  76 \r
  77         ''\r
  78 );\r
  79 \r
  80 # Upload is permitted.\r
  81 # A regular expression is possible.\r
  82 my %UPLOAD_EXT_LIST = (\r
  83         'png'                                   =>      'PNG image',\r
  84         'p?jpe?g|jpe|jfif|pjp'  =>      'JPEG image',\r
  85         'gif'                                   =>      'GIF image',\r
  86         'xbm'                                   =>      'XBM image',\r
  87 \r
  88         'bmp|dib|rle'                   =>      'Windows BMP image',\r
  89         'pi?ct'                                 =>      'Macintosh PICT image',\r
  90         'tiff?'                                 =>      'TIFF image',\r
  91         'pdf'                                   =>      'PDF image',\r
  92         'swf'                                   =>      'Shockwave Flash',\r
  93 \r
  94         'avi'                                   =>      'Microsoft Video',\r
  95         'moo?v|qt'                              =>      'QuickTime Video',\r
  96         'm(p(e?gv?|e|v)|1v)'    =>      'MPEG Video',\r
  97         'mp(v2|2v)'                             =>      'MPEG2 Video',\r
  98 \r
  99         'midi?|kar|smf|rmi|mff' =>      'MIDI Audio',\r
 100         'wav'                                   =>      'WAVE Audio',\r
 101         'au|snd'                                =>      'ULAW Audio',\r
 102         'mp(e?ga|2|a|3)|abs'    =>      'MPEG Audio',\r
 103 \r
 104         'zip'                                   =>      'ZIP Compress',\r
 105         'lzh'                                   =>      'LZH Compress',\r
 106         'cab'                                   =>      'CAB Compress',\r
 107 \r
 108         'd?html?'                               =>      'HTML',\r
 109         'rtf|rtx'                               =>      'RichText',\r
 110         'txt|text'                              =>      'Text',\r
 111 \r
 112         ''\r
 113 );\r
 114 \r
 115 \r
 116 # sjis or euc\r
 117 my $CHARCODE = 'sjis';\r
 118 \r
 119 $TRANS_2BYTE_CODE = 0;\r
 120 \r
 121 ##############################################################################\r
 122 # Summary\r
 123 #\r
 124 # Form Read input\r
 125 #\r
 126 # Parameters\r
 127 # Returns\r
 128 # Memo\r
 129 ##############################################################################\r
 130 sub read_input\r
 131 {\r
 132 eval("use File::Copy;");\r
 133 eval("use File::Path;");\r
 134 \r
 135         my ($FORM) = @_;\r
 136 \r
 137         if (defined $CHMOD_ON_FOLDER_CREATE && !$CHMOD_ON_FOLDER_CREATE) {\r
 138                 mkdir("$img_dir");\r
 139         }\r
 140         else {\r
 141                 umask(000);\r
 142                 if (defined $CHMOD_ON_FOLDER_CREATE) {\r
 143                         mkdir("$img_dir",$CHMOD_ON_FOLDER_CREATE);\r
 144                 }\r
 145                 else {\r
 146                         mkdir("$img_dir",0777);\r
 147                 }\r
 148         }\r
 149 \r
 150         undef $img_data_exists;\r
 151         undef @NEWFNAMES;\r
 152         undef @NEWFNAME_DATA;\r
 153 \r
 154         if($ENV{'CONTENT_LENGTH'} > 10000000 || $ENV{'CONTENT_LENGTH'} > $MAX_CONTENT_SIZE * 1024) {\r
 155                 &upload_error(\r
 156                         'Size Error',\r
 157                         sprintf(\r
 158                                 "Transmitting size is too large.MAX <strong>%d KB</strong> Now Size <strong>%d KB</strong>(<strong>%d bytes</strong> Over)",\r
 159                                 $MAX_CONTENT_SIZE,\r
 160                                 int($ENV{'CONTENT_LENGTH'} / 1024),\r
 161                                 $ENV{'CONTENT_LENGTH'} - $MAX_CONTENT_SIZE * 1024\r
 162                         )\r
 163                 );\r
 164         }\r
 165 \r
 166         my $Buffer;\r
 167         if($ENV{'CONTENT_TYPE'} =~ /multipart\/form-data/) {\r
 168                 # METHOD POST only\r
 169                 return  unless($ENV{'CONTENT_LENGTH'});\r
 170 \r
 171                 binmode(STDIN);\r
 172                 # STDIN A pause character is detected.'(MacIE3.0 boundary of $ENV{'CONTENT_TYPE'} cannot be trusted.)\r
 173                 my $Boundary = <STDIN>;\r
 174                 $Boundary =~ s/\x0D\x0A//;\r
 175                 $Boundary = quotemeta($Boundary);\r
 176                 while(<STDIN>) {\r
 177                         if(/^\s*Content-Disposition:/i) {\r
 178                                 my($name,$ContentType,$FileName);\r
 179                                 # form data get\r
 180                                 if(/\bname="([^"]+)"/i || /\bname=([^\s:;]+)/i) {\r
 181                                         $name = $1;\r
 182                                         $name   =~ tr/+/ /;\r
 183                                         $name   =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;\r
 184                                         &Encode(\$name);\r
 185                                 }\r
 186                                 if(/\bfilename="([^"]*)"/i || /\bfilename=([^\s:;]*)/i) {\r
 187                                         $FileName = $1 || 'unknown';\r
 188                                 }\r
 189                                 # head read\r
 190                                 while(<STDIN>) {\r
 191                                         last    if(! /\w/);\r
 192                                         if(/^\s*Content-Type:\s*"([^"]+)"/i || /^\s*Content-Type:\s*([^\s:;]+)/i) {\r
 193                                                 $ContentType = $1;\r
 194                                         }\r
 195                                 }\r
 196                                 # body read\r
 197                                 $value = "";\r
 198                                 while(<STDIN>) {\r
 199                                         last    if(/^$Boundary/o);\r
 200                                         $value .= $_;\r
 201                                 };\r
 202                                 $lastline = $_;\r
 203                                 $value =~s /\x0D\x0A$//;\r
 204                                 if($value ne '') {\r
 205                                         if($FileName || $ContentType) {\r
 206                                                 $img_data_exists = 1;\r
 207                                                 (\r
 208                                                         $FileName,              #\r
 209                                                         $Ext,                   #\r
 210                                                         $Length,                #\r
 211                                                         $ImageWidth,    #\r
 212                                                         $ImageHeight,   #\r
 213                                                         $ContentName    #\r
 214                                                 ) = &CheckContentType(\$value,$FileName,$ContentType);\r
 215 \r
 216                                                 $FORM{$name}    = $FileName;\r
 217                                                 $new_fname              = $FileName;\r
 218                                                 push(@NEWFNAME_DATA,"$FileName\t$Ext\t$Length\t$ImageWidth\t$ImageHeight\t$ContentName");\r
 219 \r
 220                                                 # Multi-upload correspondence\r
 221                                                 push(@NEWFNAMES,$new_fname);\r
 222                                                 open(OUT,">$img_dir/$new_fname");\r
 223                                                 binmode(OUT);\r
 224                                                 eval "flock(OUT,2);" if($PM{'flock'} == 1);\r
 225                                                 print OUT $value;\r
 226                                                 eval "flock(OUT,8);" if($PM{'flock'} == 1);\r
 227                                                 close(OUT);\r
 228 \r
 229                                         } elsif($name) {\r
 230                                                 $value  =~ tr/+/ /;\r
 231                                                 $value  =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;\r
 232                                                 &Encode(\$value,'trans');\r
 233                                                 $FORM{$name} .= "\0"                    if(defined($FORM{$name}));\r
 234                                                 $FORM{$name} .= $value;\r
 235                                         }\r
 236                                 }\r
 237                         };\r
 238                         last if($lastline =~ /^$Boundary\-\-/o);\r
 239                 }\r
 240         } elsif($ENV{'CONTENT_LENGTH'}) {\r
 241                 read(STDIN,$Buffer,$ENV{'CONTENT_LENGTH'});\r
 242         }\r
 243         foreach(split(/&/,$Buffer),split(/&/,$ENV{'QUERY_STRING'})) {\r
 244                 my($name, $value) = split(/=/);\r
 245                 $name   =~ tr/+/ /;\r
 246                 $name   =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;\r
 247                 $value  =~ tr/+/ /;\r
 248                 $value  =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;\r
 249 \r
 250                 &Encode(\$name);\r
 251                 &Encode(\$value,'trans');\r
 252                 $FORM{$name} .= "\0"                    if(defined($FORM{$name}));\r
 253                 $FORM{$name} .= $value;\r
 254 \r
 255         }\r
 256 \r
 257 }\r
 258 \r
 259 ##############################################################################\r
 260 # Summary\r
 261 #\r
 262 #       CheckContentType\r
 263 #\r
 264 # Parameters\r
 265 # Returns\r
 266 # Memo\r
 267 ##############################################################################\r
 268 sub CheckContentType\r
 269 {\r
 270 \r
 271         my($DATA,$FileName,$ContentType) = @_;\r
 272         my($Ext,$ImageWidth,$ImageHeight,$ContentName,$Infomation);\r
 273         my $DataLength = length($$DATA);\r
 274 \r
 275         # An unknown file type\r
 276 \r
 277         $_ = $ContentType;\r
 278         my $UnknownType = (\r
 279                 !$_\r
 280                 || /^application\/(x-)?macbinary$/i\r
 281                 || /^application\/applefile$/i\r
 282                 || /^application\/octet-stream$/i\r
 283                 || /^text\/plane$/i\r
 284                 || /^x-unknown-content-type/i\r
 285         );\r
 286 \r
 287         # MacBinary(Mac Unnecessary data are deleted.)\r
 288         if($UnknownType || $ENV{'HTTP_USER_AGENT'} =~ /Macintosh|Mac_/) {\r
 289                 if($DataLength > 128 && !unpack("C",substr($$DATA,0,1)) && !unpack("C",substr($$DATA,74,1)) && !unpack("C",substr($$DATA,82,1)) ) {\r
 290                         my $MacBinary_ForkLength = unpack("N", substr($$DATA, 83, 4));          # ForkLength Get\r
 291                         my $MacBinary_FileName = quotemeta(substr($$DATA, 2, unpack("C",substr($$DATA, 1, 1))));\r
 292                         if($MacBinary_FileName && $MacBinary_ForkLength && $DataLength >= $MacBinary_ForkLength + 128\r
 293                                         && ($FileName =~ /$MacBinary_FileName/i || substr($$DATA,102,4) eq 'mBIN')) {   # DATA TOP 128byte MacBinary!!\r
 294                                 $$DATA                          = substr($$DATA,128,$MacBinary_ForkLength);\r
 295                                 my $ResourceLength      = $DataLength - $MacBinary_ForkLength - 128;\r
 296                                 $DataLength                     = $MacBinary_ForkLength;\r
 297                         }\r
 298                 }\r
 299         }\r
 300 \r
 301         # A file name is changed into EUC.\r
 302 #       &jcode::convert(\$FileName,'euc',$FormCodeDefault);\r
 303 #       &jcode::h2z_euc(\$FileName);\r
 304         $FileName =~ s/^.*\\//;                                 # Windows, Mac\r
 305         $FileName =~ s/^.*\///;                                 # UNIX\r
 306         $FileName =~ s/&/&amp;/g;\r
 307         $FileName =~ s/"/&quot;/g;\r
 308         $FileName =~ s/</&lt;/g;\r
 309         $FileName =~ s/>/&gt;/g;\r
 310 #\r
 311 #       if($CHARCODE ne 'euc') {\r
 312 #               &jcode::convert(\$FileName,$CHARCODE,'euc');\r
 313 #       }\r
 314 \r
 315         # An extension is extracted and it changes into a small letter.\r
 316         my $FileExt;\r
 317         if($FileName =~ /\.(\w+)$/) {\r
 318                 $FileExt = $1;\r
 319                 $FileExt =~ tr/A-Z/a-z/;\r
 320         }\r
 321 \r
 322         # Executable file detection (ban on upload)\r
 323         if($$DATA =~ /^MZ/) {\r
 324                 $Ext = 'exe';\r
 325         }\r
 326         # text\r
 327         if(!$Ext && ($UnknownType || $ContentType =~ /^text\//i || $ContentType =~ /^application\/(?:rtf|richtext)$/i || $ContentType =~ /^image\/x-xbitmap$/i)\r
 328                                 && ! $$DATA =~ /[\000-\006\177\377]/) {\r
 329 #               $$DATA =~ s/\x0D\x0A/\n/g;\r
 330 #               $$DATA =~ tr/\x0D\x0A/\n\n/;\r
 331 #\r
 332 #               if(\r
 333 #                       $$DATA =~ /<\s*SCRIPT(?:.|\n)*?>/i\r
 334 #                               || $$DATA =~ /<\s*(?:.|\n)*?\bONLOAD\s*=(?:.|\n)*?>/i\r
 335 #                               || $$DATA =~ /<\s*(?:.|\n)*?\bONCLICK\s*=(?:.|\n)*?>/i\r
 336 #                               ) {\r
 337 #                       $Infomation = '(JavaScript contains)';\r
 338 #               }\r
 339 #               if($$DATA =~ /<\s*TABLE(?:.|\n)*?>/i\r
 340 #                               || $$DATA =~ /<\s*BLINK(?:.|\n)*?>/i\r
 341 #                               || $$DATA =~ /<\s*MARQUEE(?:.|\n)*?>/i\r
 342 #                               || $$DATA =~ /<\s*OBJECT(?:.|\n)*?>/i\r
 343 #                               || $$DATA =~ /<\s*EMBED(?:.|\n)*?>/i\r
 344 #                               || $$DATA =~ /<\s*FRAME(?:.|\n)*?>/i\r
 345 #                               || $$DATA =~ /<\s*APPLET(?:.|\n)*?>/i\r
 346 #                               || $$DATA =~ /<\s*FORM(?:.|\n)*?>/i\r
 347 #                               || $$DATA =~ /<\s*(?:.|\n)*?\bSRC\s*=(?:.|\n)*?>/i\r
 348 #                               || $$DATA =~ /<\s*(?:.|\n)*?\bDYNSRC\s*=(?:.|\n)*?>/i\r
 349 #                               ) {\r
 350 #                       $Infomation = '(the HTML tag which is not safe is included)';\r
 351 #               }\r
 352 \r
 353                 if($FileExt =~ /^txt$/i || $FileExt =~ /^cgi$/i || $FileExt =~ /^pl$/i) {                                                               # Text File\r
 354                         $Ext = 'txt';\r
 355                 } elsif($ContentType =~ /^text\/html$/i || $FileExt =~ /html?/i || $$DATA =~ /<\s*HTML(?:.|\n)*?>/i) {  # HTML File\r
 356                         $Ext = 'html';\r
 357                 } elsif($ContentType =~ /^image\/x-xbitmap$/i || $FileExt =~ /^xbm$/i) {                                                                # XBM(x-BitMap) Image\r
 358                         my $XbmName = $1;\r
 359                         my ($XbmWidth, $XbmHeight);\r
 360                         if($$DATA =~ /\#define\s*$XbmName\_width\s*(\d+)/i) {\r
 361                                 $XbmWidth = $1;\r
 362                         }\r
 363                         if($$DATA =~ /\#define\s*$XbmName\_height\s*(\d+)/i) {\r
 364                                 $XbmHeight = $1;\r
 365                         }\r
 366                         if($XbmWidth && $XbmHeight) {\r
 367                                 $Ext = 'xbm';\r
 368                                 $ImageWidth             = $XbmWidth;\r
 369                                 $ImageHeight    = $XbmHeight;\r
 370                         }\r
 371                 } else {                #\r
 372                         $Ext = 'txt';\r
 373                 }\r
 374         }\r
 375 \r
 376         # image\r
 377         if(!$Ext && ($UnknownType || $ContentType =~ /^image\//i)) {\r
 378                 # PNG\r
 379                 if($$DATA =~ /^\x89PNG\x0D\x0A\x1A\x0A/) {\r
 380                         if(substr($$DATA, 12, 4) eq 'IHDR') {\r
 381                                 $Ext = 'png';\r
 382                                 ($ImageWidth, $ImageHeight) = unpack("N2", substr($$DATA, 16, 8));\r
 383                         }\r
 384                 } elsif($$DATA =~ /^GIF8(?:9|7)a/) {                                                                                                                    # GIF89a(modified), GIF89a, GIF87a\r
 385                         $Ext = 'gif';\r
 386                         ($ImageWidth, $ImageHeight) = unpack("v2", substr($$DATA, 6, 4));\r
 387                 } elsif($$DATA =~ /^II\x2a\x00\x08\x00\x00\x00/ || $$DATA =~ /^MM\x00\x2a\x00\x00\x00\x08/) {   # TIFF\r
 388                         $Ext = 'tif';\r
 389                 } elsif($$DATA =~ /^BM/) {                                                                                                                                              # BMP\r
 390                         $Ext = 'bmp';\r
 391                 } elsif($$DATA =~ /^\xFF\xD8\xFF/ || $$DATA =~ /JFIF/) {                                                                                # JPEG\r
 392                         my $HeaderPoint = index($$DATA, "\xFF\xD8\xFF", 0);\r
 393                         my $Point = $HeaderPoint + 2;\r
 394                         while($Point < $DataLength) {\r
 395                                 my($Maker, $MakerType, $MakerLength) = unpack("C2n",substr($$DATA,$Point,4));\r
 396                                 if($Maker != 0xFF || $MakerType == 0xd9 || $MakerType == 0xda) {\r
 397                                         last;\r
 398                                 } elsif($MakerType >= 0xC0 && $MakerType <= 0xC3) {\r
 399                                         $Ext = 'jpg';\r
 400                                         ($ImageHeight, $ImageWidth) = unpack("n2", substr($$DATA, $Point + 5, 4));\r
 401                                         if($HeaderPoint > 0) {\r
 402                                                 $$DATA = substr($$DATA, $HeaderPoint);\r
 403                                                 $DataLength = length($$DATA);\r
 404                                         }\r
 405                                         last;\r
 406                                 } else {\r
 407                                         $Point += $MakerLength + 2;\r
 408                                 }\r
 409                         }\r
 410                 }\r
 411         }\r
 412 \r
 413         # audio\r
 414         if(!$Ext && ($UnknownType || $ContentType =~ /^audio\//i)) {\r
 415                 # MIDI Audio\r
 416                 if($$DATA =~ /^MThd/) {\r
 417                         $Ext = 'mid';\r
 418                 } elsif($$DATA =~ /^\x2esnd/) {         # ULAW Audio\r
 419                         $Ext = 'au';\r
 420                 } elsif($$DATA =~ /^RIFF/ || $$DATA =~ /^ID3/ && $$DATA =~ /RIFF/) {\r
 421                         my $HeaderPoint = index($$DATA, "RIFF", 0);\r
 422                         $_ = substr($$DATA, $HeaderPoint + 8, 8);\r
 423                         if(/^WAVEfmt $/) {\r
 424                                 # WAVE\r
 425                                 if(unpack("V",substr($$DATA, $HeaderPoint + 16, 4)) == 16) {\r
 426                                         $Ext = 'wav';\r
 427                                 } else {                                        # RIFF WAVE MP3\r
 428                                         $Ext = 'mp3';\r
 429                                 }\r
 430                         } elsif(/^RMIDdata$/) {                 # RIFF MIDI\r
 431                                 $Ext = 'rmi';\r
 432                         } elsif(/^RMP3data$/) {                 # RIFF MP3\r
 433                                 $Ext = 'rmp';\r
 434                         }\r
 435                         if($ContentType =~ /^audio\//i) {\r
 436                                 $Infomation .= '(RIFF '. substr($$DATA, $HeaderPoint + 8, 4). ')';\r
 437                         }\r
 438                 }\r
 439         }\r
 440 \r
 441         # a binary file\r
 442         unless ($Ext) {\r
 443                 # PDF image\r
 444                 if($$DATA =~ /^\%PDF/) {\r
 445                         # Picture size is not measured.\r
 446                         $Ext = 'pdf';\r
 447                 } elsif($$DATA =~ /^FWS/) {             # Shockwave Flash\r
 448                         $Ext = 'swf';\r
 449                 } elsif($$DATA =~ /^RIFF/ || $$DATA =~ /^ID3/ && $$DATA =~ /RIFF/) {\r
 450                         my $HeaderPoint = index($$DATA, "RIFF", 0);\r
 451                         $_ = substr($$DATA,$HeaderPoint + 8, 8);\r
 452                         # AVI\r
 453                         if(/^AVI LIST$/) {\r
 454                                 $Ext = 'avi';\r
 455                         }\r
 456                         if($ContentType =~ /^video\//i) {\r
 457                                 $Infomation .= '(RIFF '. substr($$DATA, $HeaderPoint + 8, 4). ')';\r
 458                         }\r
 459                 } elsif($$DATA =~ /^PK/) {                      # ZIP Compress File\r
 460                         $Ext = 'zip';\r
 461                 } elsif($$DATA =~ /^MSCF/) {            # CAB Compress File\r
 462                         $Ext = 'cab';\r
 463                 } elsif($$DATA =~ /^Rar\!/) {           # RAR Compress File\r
 464                         $Ext = 'rar';\r
 465                 } elsif(substr($$DATA, 2, 5) =~ /^\-lh(\d+|d)\-$/) {            # LHA Compress File\r
 466                         $Infomation .= "(lh$1)";\r
 467                         $Ext = 'lzh';\r
 468                 } elsif(substr($$DATA, 325, 25) eq "Apple Video Media Handler" || substr($$DATA, 325, 30) eq "Apple \x83\x72\x83\x66\x83\x49\x81\x45\x83\x81\x83\x66\x83\x42\x83\x41\x83\x6E\x83\x93\x83\x68\x83\x89") {\r
 469                         # QuickTime\r
 470                         $Ext = 'mov';\r
 471                 }\r
 472         }\r
 473 \r
 474         # Header analysis failure\r
 475         unless ($Ext) {\r
 476                 # It will be followed if it applies for the MIME type from the browser.\r
 477                 foreach (keys %UPLOAD_CONTENT_TYPE_LIST) {\r
 478                         next unless ($_);\r
 479                         if($ContentType =~ /^$_$/i) {\r
 480                                 $Ext = $UPLOAD_CONTENT_TYPE_LIST{$_};\r
 481                                 $ContentName = &CheckContentExt($Ext);\r
 482                                 if(\r
 483                                         grep {$_ eq $Ext;} (\r
 484                                                 'png',\r
 485                                                 'gif',\r
 486                                                 'jpg',\r
 487                                                 'xbm',\r
 488                                                 'tif',\r
 489                                                 'bmp',\r
 490                                                 'pdf',\r
 491                                                 'swf',\r
 492                                                 'mov',\r
 493                                                 'zip',\r
 494                                                 'cab',\r
 495                                                 'lzh',\r
 496                                                 'rar',\r
 497                                                 'mid',\r
 498                                                 'rmi',\r
 499                                                 'au',\r
 500                                                 'wav',\r
 501                                                 'avi',\r
 502                                                 'exe'\r
 503                                         )\r
 504                                 ) {\r
 505                                         $Infomation .= ' / Header analysis failure';\r
 506                                 }\r
 507                                 if($Ext ne $FileExt && &CheckContentExt($FileExt) eq $ContentName) {\r
 508                                         $Ext = $FileExt;\r
 509                                 }\r
 510                                 last;\r
 511                         }\r
 512                 }\r
 513                 # a MIME type is unknown--It judges from an extension.\r
 514                 unless ($Ext) {\r
 515                         $ContentName = &CheckContentExt($FileExt);\r
 516                         if($ContentName) {\r
 517                                 $Ext = $FileExt;\r
 518                                 $Infomation .= ' /      MIME type is unknown('. $ContentType. ')';\r
 519                                 last;\r
 520                         }\r
 521                 }\r
 522         }\r
 523 \r
 524 #       $ContentName = &CheckContentExt($Ext)   unless($ContentName);\r
 525 #       if($Ext && $ContentName) {\r
 526 #               $ContentName .=  $Infomation;\r
 527 #       } else {\r
 528 #               &upload_error(\r
 529 #                       'Extension Error',\r
 530 #                       "$FileName A not corresponding extension ($Ext)<BR>The extension which can be responded ". join(',', sort values(%UPLOAD_EXT_LIST))\r
 531 #               );\r
 532 #       }\r
 533 \r
 534 #       # SSI Tag Deletion\r
 535 #       if($Ext =~ /.?html?/ && $$DATA =~ /<\!/) {\r
 536 #               foreach (\r
 537 #                       'config',\r
 538 #                       'echo',\r
 539 #                       'exec',\r
 540 #                       'flastmod',\r
 541 #                       'fsize',\r
 542 #                       'include'\r
 543 #               ) {\r
 544 #                       $$DATA =~ s/\#\s*$_/\&\#35\;$_/ig\r
 545 #               }\r
 546 #       }\r
 547 \r
 548         return (\r
 549                 $FileName,\r
 550                 $Ext,\r
 551                 int($DataLength / 1024 + 1),\r
 552                 $ImageWidth,\r
 553                 $ImageHeight,\r
 554                 $ContentName\r
 555         );\r
 556 }\r
 557 \r
 558 ##############################################################################\r
 559 # Summary\r
 560 #\r
 561 # Extension discernment\r
 562 #\r
 563 # Parameters\r
 564 # Returns\r
 565 # Memo\r
 566 ##############################################################################\r
 567 \r
 568 sub CheckContentExt\r
 569 {\r
 570 \r
 571         my($Ext) = @_;\r
 572         my $ContentName;\r
 573         foreach (keys %UPLOAD_EXT_LIST) {\r
 574                 next    unless ($_);\r
 575                 if($_ && $Ext =~ /^$_$/) {\r
 576                         $ContentName = $UPLOAD_EXT_LIST{$_};\r
 577                         last;\r
 578                 }\r
 579         }\r
 580         return $ContentName;\r
 581 \r
 582 }\r
 583 \r
 584 ##############################################################################\r
 585 # Summary\r
 586 #\r
 587 # Form decode\r
 588 #\r
 589 # Parameters\r
 590 # Returns\r
 591 # Memo\r
 592 ##############################################################################\r
 593 sub Encode\r
 594 {\r
 595 \r
 596         my($value,$Trans) = @_;\r
 597 \r
 598 #       my $FormCode = &jcode::getcode($value) || $FormCodeDefault;\r
 599 #       $FormCodeDefault ||= $FormCode;\r
 600 #\r
 601 #       if($Trans && $TRANS_2BYTE_CODE) {\r
 602 #               if($FormCode ne 'euc') {\r
 603 #                       &jcode::convert($value, 'euc', $FormCode);\r
 604 #               }\r
 605 #               &jcode::tr(\r
 606 #                       $value,\r
 607 #                       "\xA3\xB0-\xA3\xB9\xA3\xC1-\xA3\xDA\xA3\xE1-\xA3\xFA",\r
 608 #                       '0-9A-Za-z'\r
 609 #               );\r
 610 #               if($CHARCODE ne 'euc') {\r
 611 #                       &jcode::convert($value,$CHARCODE,'euc');\r
 612 #               }\r
 613 #       } else {\r
 614 #               if($CHARCODE ne $FormCode) {\r
 615 #                       &jcode::convert($value,$CHARCODE,$FormCode);\r
 616 #               }\r
 617 #       }\r
 618 #       if($CHARCODE eq 'euc') {\r
 619 #               &jcode::h2z_euc($value);\r
 620 #       } elsif($CHARCODE eq 'sjis') {\r
 621 #               &jcode::h2z_sjis($value);\r
 622 #       }\r
 623 \r
 624 }\r
 625 \r
 626 ##############################################################################\r
 627 # Summary\r
 628 #\r
 629 # Error Msg\r
 630 #\r
 631 # Parameters\r
 632 # Returns\r
 633 # Memo\r
 634 ##############################################################################\r
 635 \r
 636 sub upload_error\r
 637 {\r
 638 \r
 639         local($error_message)   = $_[0];\r
 640         local($error_message2)  = $_[1];\r
 641 \r
 642         print "Content-type: text/html\n\n";\r
 643         print<<EOF;\r
 644 <HTML>\r
 645 <HEAD>\r
 646 <TITLE>Error Message</TITLE></HEAD>\r
 647 <BODY>\r
 648 <table border="1" cellspacing="10" cellpadding="10">\r
 649         <TR bgcolor="#0000B0">\r
 650         <TD bgcolor="#0000B0" NOWRAP><font size="-1" color="white"><B>Error Message</B></font></TD>\r
 651         </TR>\r
 652 </table>\r
 653 <UL>\r
 654 <H4> $error_message </H4>\r
 655 $error_message2 <BR>\r
 656 </UL>\r
 657 </BODY>\r
 658 </HTML>\r
 659 EOF\r
 660         &rm_tmp_uploaded_files;                 # Image Temporary deletion\r
 661         exit;\r
 662 }\r
 663 \r
 664 ##############################################################################\r
 665 # Summary\r
 666 #\r
 667 # Image Temporary deletion\r
 668 #\r
 669 # Parameters\r
 670 # Returns\r
 671 # Memo\r
 672 ##############################################################################\r
 673 \r
 674 sub rm_tmp_uploaded_files\r
 675 {\r
 676         if($img_data_exists == 1){\r
 677                 sleep 1;\r
 678                 foreach $fname_list(@NEWFNAMES) {\r
 679                         if(-e "$img_dir/$fname_list") {\r
 680                                 unlink("$img_dir/$fname_list");\r
 681                         }\r
 682                 }\r
 683         }\r
 684 \r
 685 }\r
 686 1;\r