src/chxj_img_conv_format.c

   1 /*
   2  * Copyright (C) 2005 QSDN,Inc. All rights reserved.
   3  * Copyright (C) 2005 Atsushi Konno All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <libgen.h>
  18 #include "mod_chxj.h"
  19 #include "chxj_img_conv_format.h"
  20 #include "chxj_specified_device.h"
  21 #include "chxj_str_util.h"
  22 #include "chxj_qr_code.h"
  23 #include "chxj_apply_convrule.h"
  24 #include "chxj_url_encode.h"
  25 #include "qs_parse_string.h"
  26
  27 #include "http_core.h"
  28
  29 #include <wand/magick_wand.h>
  30
  31
  32 #define EXIT_MAGICK_ERROR() \
  33   do { \
  34     char *description; ExceptionType severity; \
  35     description=MagickGetException(magick_wand,&severity); \
  36     ap_log_rerror(APLOG_MARK,APLOG_DEBUG, 0, r,"%s %s %d %s\n",__FILE__,(__func__),__LINE__,description); \
  37     description=(char *) MagickRelinquishMemory(description); \
  38     DestroyMagickWand(magick_wand); \
  39   }while(1)
  40
  41 typedef enum img_conv_mode_t {
  42   IMG_CONV_MODE_NORMAL = 0,
  43   IMG_CONV_MODE_THUMBNAIL,
  44   IMG_CONV_MODE_WALLPAPER,
  45   IMG_CONV_MODE_EZGET,
  46 } img_conv_mode_t;
  47
  48 /*----------------------------------------------------------------------------*/
  49 /* User-Agent use flag                                                        */
  50 /*----------------------------------------------------------------------------*/
  51 typedef enum _ua_use_flag_t {
  52   UA_USE=0,               /* User-Agent is used.                              */
  53   UA_IGN,                 /* User-Agent is disregarded.                       */
  54 } ua_use_flag_t;
  55
  56 /*----------------------------------------------------------------------------*/
  57 /* Request parameter maintenance structure                                    */
  58 /*----------------------------------------------------------------------------*/
  59 typedef struct query_string_param_t query_string_param_t;
  60
  61 struct query_string_param_t {
  62   img_conv_mode_t   mode;
  63   char*             user_agent;
  64   ua_use_flag_t     ua_flag;
  65
  66   char*             name;      /* for EZGET */
  67   long              offset;    /* for EZGET */
  68   long              count;     /* for EZGET */
  69   int               width;
  70   int               height;
  71 };
  72
  73 /*----------------------------------------------------------------------------*/
  74 /* Device_spec when User-Agent is disregarded                                 */
  75 /*----------------------------------------------------------------------------*/
  76 static device_table v_ignore_spec = {
  77   NULL,
  78   "IGN",
  79   "IGN",
  80   CHXJ_SPEC_HTML,
  81   640,
  82   480,
  83   640,
  84   480,
  85   1024*1024,
  86   1,
  87   1,
  88   1,
  89   0,
  90   0,
  91   96,
  92   96,
  93   65536,
  94   NULL,
  95 };
  96
  97 /*----------------------------------------------------------------------------*/
  98 /* CRC calculation table for AU                                               */
  99 /*----------------------------------------------------------------------------*/
 100 static unsigned short  AU_CRC_TBL[256] = {
 101   0x0000,0x1021,0x2042,0x3063,0x4084,0x50A5,0x60C6,0x70E7,
 102   0x8108,0x9129,0xA14A,0xB16B,0xC18C,0xD1AD,0xE1CE,0xF1EF,
 103   0x1231,0x0210,0x3273,0x2252,0x52B5,0x4294,0x72F7,0x62D6,
 104   0x9339,0x8318,0xB37B,0xA35A,0xD3BD,0xC39C,0xF3FF,0xE3DE,
 105   0x2462,0x3443,0x0420,0x1401,0x64E6,0x74C7,0x44A4,0x5485,
 106   0xA56A,0xB54B,0x8528,0x9509,0xE5EE,0xF5CF,0xC5AC,0xD58D,
 107   0x3653,0x2672,0x1611,0x0630,0x76D7,0x66F6,0x5695,0x46B4,
 108   0xB75B,0xA77A,0x9719,0x8738,0xF7DF,0xE7FE,0xD79D,0xC7BC,
 109   0x48C4,0x58E5,0x6886,0x78A7,0x0840,0x1861,0x2802,0x3823,
 110   0xC9CC,0xD9ED,0xE98E,0xF9AF,0x8948,0x9969,0xA90A,0xB92B,
 111   0x5AF5,0x4AD4,0x7AB7,0x6A96,0x1A71,0x0A50,0x3A33,0x2A12,
 112   0xDBFD,0xCBDC,0xFBBF,0xEB9E,0x9B79,0x8B58,0xBB3B,0xAB1A,
 113   0x6CA6,0x7C87,0x4CE4,0x5CC5,0x2C22,0x3C03,0x0C60,0x1C41,
 114   0xEDAE,0xFD8F,0xCDEC,0xDDCD,0xAD2A,0xBD0B,0x8D68,0x9D49,
 115   0x7E97,0x6EB6,0x5ED5,0x4EF4,0x3E13,0x2E32,0x1E51,0x0E70,
 116   0xFF9F,0xEFBE,0xDFDD,0xCFFC,0xBF1B,0xAF3A,0x9F59,0x8F78,
 117   0x9188,0x81A9,0xB1CA,0xA1EB,0xD10C,0xC12D,0xF14E,0xE16F,
 118   0x1080,0x00A1,0x30C2,0x20E3,0x5004,0x4025,0x7046,0x6067,
 119   0x83B9,0x9398,0xA3FB,0xB3DA,0xC33D,0xD31C,0xE37F,0xF35E,
 120   0x02B1,0x1290,0x22F3,0x32D2,0x4235,0x5214,0x6277,0x7256,
 121   0xB5EA,0xA5CB,0x95A8,0x8589,0xF56E,0xE54F,0xD52C,0xC50D,
 122   0x34E2,0x24C3,0x14A0,0x0481,0x7466,0x6447,0x5424,0x4405,
 123   0xA7DB,0xB7FA,0x8799,0x97B8,0xE75F,0xF77E,0xC71D,0xD73C,
 124   0x26D3,0x36F2,0x0691,0x16B0,0x6657,0x7676,0x4615,0x5634,
 125   0xD94C,0xC96D,0xF90E,0xE92F,0x99C8,0x89E9,0xB98A,0xA9AB,
 126   0x5844,0x4865,0x7806,0x6827,0x18C0,0x08E1,0x3882,0x28A3,
 127   0xCB7D,0xDB5C,0xEB3F,0xFB1E,0x8BF9,0x9BD8,0xABBB,0xBB9A,
 128   0x4A75,0x5A54,0x6A37,0x7A16,0x0AF1,0x1AD0,0x2AB3,0x3A92,
 129   0xFD2E,0xED0F,0xDD6C,0xCD4D,0xBDAA,0xAD8B,0x9DE8,0x8DC9,
 130   0x7C26,0x6C07,0x5C64,0x4C45,0x3CA2,0x2C83,0x1CE0,0x0CC1,
 131   0xEF1F,0xFF3E,0xCF5D,0xDF7C,0xAF9B,0xBFBA,0x8FD9,0x9FF8,
 132   0x6E17,0x7E36,0x4E55,0x5E74,0x2E93,0x3EB2,0x0ED1,0x1EF0
 133 };
 134
 135 /*----------------------------------------------------------------------------*/
 136 /* Download page for AU                                                       */
 137 /*----------------------------------------------------------------------------*/
 138 static const char* HDML_FIRST_PAGE =
 139   "<HDML VERSION=3.0 TTL=0 PUBLIC=TRUE>\r\n"
 140   "  <NODISPLAY>\r\n"
 141   "    <ACTION TYPE=ACCEPT TASK=GOSUB DEST=\"device:data/dnld?url=%s&name=%s%s&size=%ld&disposition=%s&title=%s\">\r\n"
 142   "  </NODISPLAY>\r\n"
 143   "</HDML>\r\n";
 144
 145 static const char* HDML_SUCCESS_PAGE =
 146   "<HDML VERSION=3.0 TTL=0 PUBLIC=TRUE>\r\n"
 147   "  <DISPLAY>\r\n"
 148   "    <ACTION TYPE=ACCEPT TASK=RETURN>\r\n"
 149   "    \x83\x5f\x83\x45\x83\x93\x83\x8d\x81\x5b\x83\x68\x82\xc9\x90\xac\x8c\xf7\x82\xb5\x82\xdc\x82\xb5\x82\xbd\r\n"
 150   "  </DISPLAY>\r\n"
 151   "<HDML>\r\n";
 152
 153 static const char* HDML_FAIL_PAGE =
 154   "<HDML VERSION=3.0 TTL=0 PUBLIC=TRUE>\r\n"
 155   "  <DISPLAY>\r\n"
 156   "    <ACTION TYPE=ACCEPT TASK=RETURN>\r\n"
 157   "    \x83\x5f\x83\x45\x83\x93\x83\x8d\x81\x5b\x83\x68\x82\xc9\x8e\xb8\x94\x73\x82\xb5\x82\xdc\x82\xb5\x82\xbd\r\n"
 158   "  </DISPLAY>\r\n"
 159   "<HDML>\r\n";
 160
 161 /*----------------------------------------------------------------------------*/
 162 /* Prototype declaration                                                      */
 163 /*----------------------------------------------------------------------------*/
 164 static char*        s_create_workfile(  request_rec*,
 165                                         mod_chxj_config* ,
 166                                         const char*,
 167                                         query_string_param_t*);
 168
 169 static apr_status_t s_create_cache_file(request_rec*          r,
 170                                         const char*           tmpfile,
 171                                         device_table*         spec,
 172                                         apr_finfo_t*          st,
 173                                         query_string_param_t* qsp);
 174
 175 static apr_status_t s_send_cache_file(  device_table*         spec,
 176                                         query_string_param_t* query_string,
 177                                         request_rec*          r,
 178                                         const char*           tmpfile);
 179
 180 static apr_status_t s_header_only_cache_file(device_table*         spec,
 181                                              query_string_param_t* query_string,
 182                                              request_rec*          r,
 183                                              const char*           tmpfile);
 184
 185 static query_string_param_t* s_get_query_string_param(request_rec *r);
 186
 187 static unsigned short s_add_crc(        const char* writedata,
 188                                         apr_size_t witebyte);
 189
 190 static MagickWand* s_fixup_size(MagickWand* ,
 191                                 request_rec* r,
 192                                 device_table* spec,
 193                                 query_string_param_t *qsp);
 194
 195 static MagickWand* s_fixup_color(MagickWand* magick_wand,
 196                                  request_rec* r,
 197                                  device_table* spec,
 198                                  img_conv_mode_t mode);
 199 static MagickWand* s_fixup_depth(MagickWand* magick_wand,
 200                                  request_rec* r, device_table* spec);
 201 static MagickWand* s_img_down_sizing(MagickWand* magick_wand,
 202                                 request_rec* r, device_table* spec);
 203 static MagickWand* s_add_copyright(
 204                           MagickWand* magick_wand,
 205                           request_rec* r,
 206                           device_table* spec);
 207 static char* s_create_blob_data(request_rec* r,
 208                    device_table* spec,
 209                    query_string_param_t *qsp,
 210                    char* indata,
 211                    apr_size_t* len);
 212
 213 static int s_img_conv_format_from_file(
 214                 request_rec*          r,
 215                 mod_chxj_config*    conf,
 216                 const char*           user_agent,
 217                 query_string_param_t* qsp,
 218                 device_table*       spec);
 219
 220 int
 221 chxj_img_conv_format_handler(request_rec* r)
 222 {
 223   mod_chxj_config*      conf;
 224   query_string_param_t* qsp;
 225   char*                 user_agent;
 226   device_table*       spec;
 227   chxjconvrule_entry* entryp;
 228
 229   DBG(r, "start chxj_img_conv_format_handler()");
 230
 231   if ((*r->handler != 'c' && *r->handler != 'C')
 232   ||  (strcasecmp(r->handler, "chxj-picture")
 233   &&  strcasecmp(r->handler, "chxj-qrcode"))) {
 234     DBG(r, "end chxj_img_conv_format_handler()");
 235     return DECLINED;
 236   }
 237
 238   qsp = s_get_query_string_param(r);
 239   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
 240   if (conf == NULL) {
 241     DBG(r, "end chxj_img_conv_format_handler() conf is null");
 242     return DECLINED;
 243   }
 244
 245   if (strcasecmp(r->handler, "chxj-qrcode") == 0 &&  conf->image == CHXJ_IMG_OFF)
 246     return DECLINED;
 247
 248
 249   /*------------------------------------------------------------------------*/
 250   /* get UserAgent from http header                                         */
 251   /*------------------------------------------------------------------------*/
 252   /*--------------------------------------------------------------------------*/
 253   /* User-Agent to spec                                                       */
 254   /*--------------------------------------------------------------------------*/
 255   if (qsp->user_agent) {
 256     user_agent = apr_pstrdup(r->pool, qsp->user_agent);
 257   }
 258   else {
 259     entryp = chxj_apply_convrule(r, conf->convrules);
 260     if (entryp && entryp->user_agent) {
 261       user_agent = (char*)apr_table_get(r->headers_in, CHXJ_HTTP_USER_AGENT);
 262     }
 263     else {
 264       user_agent = (char*)apr_table_get(r->headers_in, HTTP_USER_AGENT);
 265     }
 266   }
 267
 268
 269
 270   if (qsp->ua_flag == UA_IGN)
 271     spec = &v_ignore_spec;
 272   else
 273     spec = chxj_specified_device(r, user_agent);
 274
 275   DBG1(r,"found device_name=[%s]", spec->device_name);
 276   DBG1(r,"User-Agent=[%s]", user_agent);
 277
 278   if (spec->width == 0 || spec->heigh == 0)
 279     return DECLINED;
 280
 281   return s_img_conv_format_from_file(r, conf, user_agent, qsp, spec);
 282 }
 283
 284
 285
 286 /**
 287  * It converts it from ImageData corresponding to each model.
 288  *
 289  * @param r   [i]
 290  * @param src [i]   It is former image binary data.
 291  * @param len [i/o] It is length of former image binary data.
 292  */
 293 char*
 294 chxj_exchange_image(request_rec *r, const char** src, apr_size_t* len)
 295 {
 296   mod_chxj_config*      conf;
 297   query_string_param_t* qsp;
 298   char*                 user_agent;
 299   device_table*         spec;
 300   char*                 dst;
 301   char*                 conv_check;
 302   chxjconvrule_entry* entryp;
 303
 304   DBG(r, "start chxj_exchange_image()");
 305
 306   conv_check = (char*)apr_table_get(r->headers_in, "CHXJ_IMG_CONV");
 307   if (conv_check) {
 308     DBG(r, "end chxj_exchnage_image() already convert.");
 309     return NULL;
 310   }
 311
 312
 313   qsp = s_get_query_string_param(r);
 314   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
 315   if (conf == NULL) {
 316     DBG(r, "end chxj_exchange_image()");
 317     return NULL;
 318   }
 319
 320   /*--------------------------------------------------------------------------*/
 321   /* User-Agent to spec                                                       */
 322   /*--------------------------------------------------------------------------*/
 323   if (qsp->user_agent) {
 324     user_agent = apr_pstrdup(r->pool, qsp->user_agent);
 325   }
 326   else {
 327     entryp = chxj_apply_convrule(r, conf->convrules);
 328     if (entryp && entryp->user_agent) {
 329       user_agent = (char*)apr_table_get(r->headers_in, CHXJ_HTTP_USER_AGENT);
 330     }
 331     else {
 332       user_agent = (char*)apr_table_get(r->headers_in, HTTP_USER_AGENT);
 333     }
 334   }
 335
 336   if (qsp->ua_flag == UA_IGN)
 337     spec = &v_ignore_spec;
 338   else
 339     spec = chxj_specified_device(r, user_agent);
 340
 341   DBG1(r,"found device_name=[%s]", spec->device_name);
 342   DBG1(r, "User-Agent=[%s]", user_agent);
 343
 344   if (spec->width == 0 || spec->heigh == 0)
 345     return NULL;
 346
 347   dst = s_create_blob_data(r, spec, qsp, (char*)*src, len);
 348   if (dst == NULL)
 349     *len = 0;
 350
 351   DBG(r, "end chxj_exchange_image()");
 352
 353   return dst;
 354 }
 355
 356 static int
 357 s_img_conv_format_from_file(
 358                 request_rec*          r,
 359                 mod_chxj_config*    conf,
 360                 const char*           user_agent,
 361                 query_string_param_t* qsp,
 362                 device_table*       spec)
 363 {
 364   apr_status_t   rv;
 365   apr_finfo_t    st;
 366   apr_finfo_t    cache_st;
 367   char*          tmpfile;
 368
 369   /*--------------------------------------------------------------------------*/
 370   /* Create Workfile Name                                                     */
 371   /*--------------------------------------------------------------------------*/
 372   tmpfile = s_create_workfile(r, conf, user_agent, qsp);
 373   DBG1(r,"workfile=[%s]", tmpfile);
 374
 375   rv = apr_stat(&st, r->filename, APR_FINFO_MIN, r->pool);
 376   if (rv != APR_SUCCESS)
 377     return HTTP_NOT_FOUND;
 378
 379
 380   DBG1(r,"found [%s]", r->filename);
 381   rv = apr_stat(&cache_st, tmpfile, APR_FINFO_MIN, r->pool);
 382   DBG1(r,"found [%s]", r->filename);
 383
 384   if (rv != APR_SUCCESS || cache_st.ctime < st.mtime) {
 385     /*------------------------------------------------------------------------*/
 386     /* It tries to make the cash file when it doesn't exist or there is       */
 387     /* change time later since the making time of the cash file.              */
 388     /*------------------------------------------------------------------------*/
 389     rv = s_create_cache_file(r,tmpfile, spec, &st, qsp);
 390     if (rv != OK)
 391       return rv;
 392   }
 393
 394   DBG1(r,"color=[%d]", spec->color);
 395   if (! r->header_only)  {
 396     rv = s_send_cache_file(spec, qsp,r, tmpfile);
 397     if (rv != OK)
 398       return rv;
 399   }
 400   else {
 401     rv = s_header_only_cache_file(spec, qsp, r, tmpfile);
 402     if (rv != OK)
 403       return rv;
 404   }
 405   apr_table_setn(r->headers_in, "CHXJ_IMG_CONV", "done");
 406
 407   DBG(r,"end chxj_img_conv_format");
 408
 409   return OK;
 410 }
 411
 412
 413 static apr_status_t
 414 s_create_cache_file(request_rec*       r,
 415                        const char*     tmpfile,
 416                        device_table* spec,
 417                        apr_finfo_t*    st,
 418                        query_string_param_t *qsp)
 419 {
 420   apr_status_t       rv;
 421   apr_size_t         readbyte;
 422   apr_size_t         writebyte;
 423   unsigned short     crc;
 424   img_conv_mode_t    mode = qsp->mode;
 425
 426   char*              writedata = NULL;
 427   char*              readdata  = NULL;
 428
 429   apr_file_t*        fout;
 430   apr_file_t*        fin;
 431
 432   MagickWand*        magick_wand;
 433
 434   if ((*r->handler == 'c' || *r->handler == 'C')
 435   &&  strcasecmp(r->handler, "chxj-qrcode") == 0) {
 436     /*------------------------------------------------------------------------*/
 437     /* QRCODEÍÑ¤Î¥Õ¥¡¥¤¥ë¤Î¾ì¹ç                                               */
 438     /*------------------------------------------------------------------------*/
 439     Doc       doc;
 440     Node*     root;
 441     qr_code_t qrcode;
 442     int       sts;
 443
 444     memset(&doc,    0, sizeof(Doc));
 445     memset(&qrcode, 0, sizeof(qr_code_t));
 446     doc.r = r;
 447     doc.parse_mode  = PARSE_MODE_CHTML;
 448     qrcode.doc      = &doc;
 449     qrcode.r        = r;
 450
 451     qs_init_malloc(&doc);
 452
 453     root = qs_parse_file(&doc, r->filename);
 454
 455     chxj_qrcode_node_to_qrcode(&qrcode, root);
 456
 457     qs_all_free(&doc,QX_LOGMARK);
 458
 459     sts = chxj_qrcode_create_image_data(&qrcode, &readdata, &readbyte);
 460     if (sts != OK) {
 461       ERR(r, "qrcode create failed.");
 462       return sts;
 463     }
 464   }
 465   else {
 466     /*------------------------------------------------------------------------*/
 467     /* ÄÌ¾ï¤Î¥¤¥á¡¼¥¸¥Õ¥¡¥¤¥ë¤Î¾ì¹ç                                           */
 468     /*------------------------------------------------------------------------*/
 469     rv = apr_file_open(&fin,
 470                     r->filename,
 471                     APR_READ|APR_BINARY ,
 472                     APR_OS_DEFAULT,
 473                     r->pool);
 474     if (rv != APR_SUCCESS) {
 475       DBG1(r,"file open failed.[%s]", r->filename);
 476       return HTTP_NOT_FOUND;
 477     }
 478
 479     readdata = apr_palloc(r->pool, st->size);
 480     rv = apr_file_read_full(fin, (void*)readdata, st->size, &readbyte);
 481     if (rv != APR_SUCCESS || readbyte != st->size) {
 482       DBG1(r,"file read failed.[%s]", r->filename);
 483       apr_file_close(fin);
 484
 485       return HTTP_NOT_FOUND;
 486     }
 487   }
 488   DBG(r,"start img convert");
 489
 490
 491   magick_wand = NewMagickWand();
 492   if (MagickReadImageBlob(magick_wand,readdata, readbyte) == MagickFalse) {
 493     EXIT_MAGICK_ERROR();
 494     return HTTP_NOT_FOUND;
 495   }
 496
 497   /*
 498    * The size of the image is changed.
 499    */
 500   DBG(r,"call s_fixup_size()");
 501
 502   if ((magick_wand = s_fixup_size(magick_wand, r, spec, qsp)) == NULL)
 503     return HTTP_NOT_FOUND;
 504
 505   /*
 506    * The colors of the image is changed.
 507    */
 508   DBG(r,"call s_fixup_color()");
 509
 510   if ((magick_wand = s_fixup_color(magick_wand, r,spec, mode)) == NULL)
 511     return HTTP_NOT_FOUND;
 512
 513   /*
 514    * DEPTH of the image is changed.
 515    */
 516   DBG(r,"call s_fixup_depth()");
 517
 518   if ((magick_wand = s_fixup_depth(magick_wand, r, spec)) == NULL)
 519     return HTTP_NOT_FOUND;
 520
 521
 522
 523   DBG(r,"start convert and compression");
 524
 525   if (spec->available_jpeg) {
 526     if (MagickSetImageCompression(magick_wand,JPEGCompression) == MagickFalse) {
 527       EXIT_MAGICK_ERROR();
 528       return HTTP_NOT_FOUND;
 529     }
 530
 531     if (MagickSetImageFormat(magick_wand, "jpg") == MagickFalse) {
 532       EXIT_MAGICK_ERROR();
 533       return HTTP_NOT_FOUND;
 534     }
 535
 536     if (MagickStripImage(magick_wand) == MagickFalse) {
 537       EXIT_MAGICK_ERROR();
 538       return HTTP_NOT_FOUND;
 539     }
 540
 541     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 542       return HTTP_NOT_FOUND;
 543
 544     r->content_type = apr_psprintf(r->pool, "image/jpeg");
 545     DBG(r,"convert to jpg");
 546   }
 547   else
 548   if (spec->available_png) {
 549
 550     if (MagickSetImageCompression(magick_wand,ZipCompression) == MagickFalse) {
 551       EXIT_MAGICK_ERROR();
 552       return HTTP_NOT_FOUND;
 553     }
 554
 555     if (MagickSetImageFormat(magick_wand, "png") == MagickFalse) {
 556       EXIT_MAGICK_ERROR();
 557       return HTTP_NOT_FOUND;
 558     }
 559
 560     if (MagickStripImage(magick_wand) == MagickFalse) {
 561       EXIT_MAGICK_ERROR();
 562       return HTTP_NOT_FOUND;
 563     }
 564
 565     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 566       return HTTP_NOT_FOUND;
 567
 568     r->content_type = apr_psprintf(r->pool, "image/png");
 569     DBG(r, "convert to png");
 570   }
 571   else
 572   if (spec->available_gif) {
 573
 574     if (MagickSetImageCompression(magick_wand,LZWCompression) == MagickFalse) {
 575       EXIT_MAGICK_ERROR();
 576       return HTTP_NOT_FOUND;
 577     }
 578
 579     if (MagickSetImageFormat(magick_wand, "gif") == MagickFalse) {
 580       EXIT_MAGICK_ERROR();
 581       return HTTP_NOT_FOUND;
 582     }
 583
 584     if (MagickStripImage(magick_wand) == MagickFalse) {
 585       EXIT_MAGICK_ERROR();
 586       return HTTP_NOT_FOUND;
 587     }
 588
 589     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 590       return HTTP_NOT_FOUND;
 591
 592     r->content_type = apr_psprintf(r->pool, "image/gif");
 593
 594     DBG(r,"convert to gif");
 595   }
 596   else
 597   if (spec->available_bmp2 || spec->available_bmp4) {
 598
 599     if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
 600       EXIT_MAGICK_ERROR();
 601       return HTTP_NOT_FOUND;
 602     }
 603
 604     if (MagickSetImageFormat(magick_wand, "bmp") == MagickFalse) {
 605       EXIT_MAGICK_ERROR();
 606       return HTTP_NOT_FOUND;
 607     }
 608
 609     if (MagickStripImage(magick_wand) == MagickFalse) {
 610       EXIT_MAGICK_ERROR();
 611       return HTTP_NOT_FOUND;
 612     }
 613
 614     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 615       return HTTP_NOT_FOUND;
 616
 617     r->content_type = apr_psprintf(r->pool, "image/bmp");
 618
 619     DBG(r, "convert to bmp(unsupported)");
 620   }
 621
 622   /*
 623    * Add Comment (Copyright and so on.)
 624    */
 625   DBG(r, "call s_add_copyright()");
 626
 627   if ((magick_wand = s_add_copyright(magick_wand, r, spec)) == NULL)
 628     return HTTP_NOT_FOUND;
 629
 630   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
 631
 632   if (! writebyte) {
 633     DestroyMagickWand(magick_wand);
 634     ERR1(r,"convert failure to Jpeg [%s]", tmpfile);
 635
 636     return HTTP_INTERNAL_SERVER_ERROR;
 637   }
 638
 639   DBG(r, "end convert and compression");
 640
 641   /* to cache */
 642   rv = apr_file_open(&fout, tmpfile,
 643                   APR_WRITE| APR_CREATE | APR_BINARY | APR_SHARELOCK ,APR_OS_DEFAULT,
 644                   r->pool);
 645   if (rv != APR_SUCCESS) {
 646     DestroyMagickWand(magick_wand);
 647     ERR1(r,"file open error.[%s]", tmpfile);
 648     return HTTP_INTERNAL_SERVER_ERROR;
 649   }
 650
 651   rv = apr_file_write(fout, (void*)writedata, &writebyte);
 652   if (rv != APR_SUCCESS) {
 653     DestroyMagickWand(magick_wand);
 654     apr_file_close(fout);
 655     return HTTP_INTERNAL_SERVER_ERROR;
 656   }
 657
 658   /*
 659    * CRC is added for AU for EzGET.
 660    */
 661   if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
 662   ||  spec->html_spec_type == CHXJ_SPEC_Hdml            ) {
 663
 664     crc = s_add_crc(writedata, writebyte);
 665
 666     rv = apr_file_putc((crc >> 8)  & 0xff, fout);
 667     if (rv != APR_SUCCESS) {
 668       DestroyMagickWand(magick_wand);
 669       return HTTP_INTERNAL_SERVER_ERROR;
 670     }
 671
 672     rv = apr_file_putc( crc        & 0xff, fout);
 673     if (rv != APR_SUCCESS) {
 674       DestroyMagickWand(magick_wand);
 675       return HTTP_INTERNAL_SERVER_ERROR;
 676     }
 677   }
 678
 679   DestroyMagickWand(magick_wand);
 680
 681   rv = apr_file_close(fout);
 682   if (rv != APR_SUCCESS) {
 683     DBG1(r,"file write error.[%s]", tmpfile);
 684     return HTTP_INTERNAL_SERVER_ERROR;
 685   }
 686
 687   return OK;
 688 }
 689
 690
 691 static char*
 692 s_create_blob_data(request_rec* r,
 693                    device_table* spec,
 694                    query_string_param_t *qsp,
 695                    char* indata,
 696                    apr_size_t* len)
 697 {
 698   apr_size_t         writebyte;
 699   unsigned short     crc;
 700   img_conv_mode_t    mode = qsp->mode;
 701
 702   char*              writedata = NULL;
 703   char*              dst       = NULL;
 704
 705   MagickWand*        magick_wand;
 706
 707   magick_wand = NewMagickWand();
 708
 709   if (MagickReadImageBlob(magick_wand,indata, *len) == MagickFalse) {
 710     EXIT_MAGICK_ERROR();
 711     return NULL;
 712   }
 713
 714   /*
 715    * The size of the image is changed.
 716    */
 717   DBG(r, "call s_fixup_size()");
 718
 719   if ((magick_wand = s_fixup_size(magick_wand, r, spec, qsp)) == NULL)
 720     return NULL;
 721
 722   /*
 723    * The colors of the image is changed.
 724    */
 725   DBG(r, "call s_fixup_color()");
 726
 727   if ((magick_wand = s_fixup_color(magick_wand, r,spec, mode)) == NULL)
 728     return NULL;
 729
 730   /*
 731    * DEPTH of the image is changed.
 732    */
 733
 734   DBG(r,"call s_fixup_depth()");
 735
 736   if ((magick_wand = s_fixup_depth(magick_wand, r, spec)) == NULL)
 737     return NULL;
 738
 739
 740
 741   DBG(r,"start convert and compression");
 742
 743   if (spec->available_jpeg) {
 744     if (MagickSetImageCompression(magick_wand,JPEGCompression) == MagickFalse) {
 745       EXIT_MAGICK_ERROR();
 746       return NULL;
 747     }
 748
 749     if (MagickSetImageFormat(magick_wand, "jpg") == MagickFalse) {
 750       EXIT_MAGICK_ERROR();
 751       return NULL;
 752     }
 753
 754     if (MagickStripImage(magick_wand) == MagickFalse) {
 755       EXIT_MAGICK_ERROR();
 756       return NULL;
 757     }
 758
 759     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 760       return NULL;
 761
 762     r->content_type = apr_psprintf(r->pool, "image/jpeg");
 763
 764     DBG(r, "convert to jpg");
 765   }
 766   else
 767   if (spec->available_png) {
 768     if (MagickSetImageCompression(magick_wand,ZipCompression) == MagickFalse) {
 769       EXIT_MAGICK_ERROR();
 770       return NULL;
 771     }
 772
 773     if (MagickSetImageFormat(magick_wand, "png") == MagickFalse) {
 774       EXIT_MAGICK_ERROR();
 775       return NULL;
 776     }
 777
 778     if (MagickStripImage(magick_wand) == MagickFalse) {
 779       EXIT_MAGICK_ERROR();
 780       return NULL;
 781     }
 782
 783     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 784       return NULL;
 785
 786     r->content_type = apr_psprintf(r->pool, "image/png");
 787
 788     DBG(r,"convert to png");
 789   }
 790   else
 791   if (spec->available_gif) {
 792
 793     if (MagickSetImageCompression(magick_wand,LZWCompression) == MagickFalse) {
 794       EXIT_MAGICK_ERROR();
 795       return NULL;
 796     }
 797
 798     if (MagickSetImageFormat(magick_wand, "gif") == MagickFalse) {
 799       EXIT_MAGICK_ERROR();
 800       return NULL;
 801     }
 802
 803     if (MagickStripImage(magick_wand) == MagickFalse) {
 804       EXIT_MAGICK_ERROR();
 805       return NULL;
 806     }
 807
 808     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 809       return NULL;
 810
 811     r->content_type = apr_psprintf(r->pool, "image/gif");
 812
 813     DBG(r,"convert to gif");
 814   }
 815   else
 816   if (spec->available_bmp2 || spec->available_bmp4) {
 817     if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
 818       EXIT_MAGICK_ERROR();
 819       return NULL;
 820     }
 821
 822     if (MagickSetImageFormat(magick_wand, "bmp") == MagickFalse) {
 823       EXIT_MAGICK_ERROR();
 824       return NULL;
 825     }
 826
 827     if (MagickStripImage(magick_wand) == MagickFalse) {
 828       EXIT_MAGICK_ERROR();
 829       return NULL;
 830     }
 831
 832     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 833       return NULL;
 834
 835     r->content_type = apr_psprintf(r->pool, "image/bmp");
 836
 837     DBG(r,"convert to bmp(unsupported)");
 838   }
 839   /*--------------------------------------------------------------------------*/
 840   /* Add Comment (Copyright and so on.)                                       */
 841   /*--------------------------------------------------------------------------*/
 842   DBG(r,"call s_add_copyright()");
 843
 844   if ((magick_wand = s_add_copyright(magick_wand, r, spec)) == NULL)
 845     return NULL;
 846
 847   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
 848
 849   if (! writebyte) {
 850     DestroyMagickWand(magick_wand);
 851     DBG(r,"convert failure to Jpeg ");
 852     return NULL;
 853   }
 854
 855   DBG(r,"end convert and compression");
 856
 857
 858
 859   dst = apr_palloc(r->pool, writebyte+2);
 860
 861   memcpy(dst, writedata, writebyte);
 862   /*--------------------------------------------------------------------------*/
 863   /* CRC is added for AU for EzGET.                                           */
 864   /*--------------------------------------------------------------------------*/
 865   if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
 866   ||  spec->html_spec_type == CHXJ_SPEC_Hdml) {
 867     crc = s_add_crc(writedata, writebyte);
 868     dst[writebyte + 0] = (crc >> 8) & 0xff;
 869     dst[writebyte + 1] = (crc     ) & 0xff;
 870     writebyte += 2;
 871   }
 872
 873   DestroyMagickWand(magick_wand);
 874
 875   *len = writebyte;
 876   return dst;
 877 }
 878
 879 static MagickWand*
 880 s_fixup_size(MagickWand* magick_wand,
 881                 request_rec* r,
 882                 device_table* spec,
 883                 query_string_param_t *qsp)
 884 {
 885   img_conv_mode_t mode = qsp->mode;
 886   int oldw;
 887   int oldh;
 888   int neww;
 889   int newh;
 890   int c_width;
 891   int c_heigh;
 892
 893   oldw = MagickGetImageWidth(magick_wand);
 894   oldh = MagickGetImageHeight(magick_wand);
 895
 896   DBG1(r,"detect width=[%d]", oldw);
 897   DBG1(r,"detect heigh=[%d]", oldh);
 898
 899   neww = oldw;
 900   newh = oldh;
 901
 902   DBG1(r,"detect spec width=[%d]", spec->width);
 903   DBG1(r,"detect spec heigh=[%d]", spec->heigh);
 904
 905   c_width = spec->width;
 906   c_heigh = spec->heigh;
 907
 908   switch(mode) {
 909   case IMG_CONV_MODE_THUMBNAIL:
 910
 911     DBG(r,"**** detect thumbnail mode ****");
 912
 913     if (neww > c_width) {
 914       newh = (int)((double)newh * (double)((double)c_width / (double)neww));
 915       neww = (int)((double)neww * (double)((double)c_width / (double)neww));
 916     }
 917     if (newh > c_heigh) {
 918       neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 919       newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 920     }
 921
 922     neww = (int)((double)(neww / 3) * 0.8);
 923     newh = (int)((double)(newh / 3) * 0.8);
 924     break;
 925
 926   case IMG_CONV_MODE_WALLPAPER:
 927   case IMG_CONV_MODE_EZGET:
 928
 929     DBG(r,"**** detect wallpaper mode ****");
 930
 931     if (spec->wp_width && spec->wp_heigh) {
 932       c_width = spec->wp_width;
 933       c_heigh = spec->wp_heigh;
 934     }
 935
 936     DBG(r,"calc new width and height");
 937
 938     neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 939     newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 940
 941     DBG2(r,"newh = [%d] neww = [%d]", newh, neww);
 942     break;
 943
 944   default:
 945
 946     DBG(r,"**** detect normal mode ****");
 947
 948     if (qsp->ua_flag != UA_IGN) {
 949       if (neww > c_width) {
 950         newh = (int)((double)newh * (double)((double)c_width / (double)neww));
 951         neww = (int)((double)neww * (double)((double)c_width / (double)neww));
 952       }
 953
 954       if (newh > c_heigh) {
 955         neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 956         newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 957       }
 958     }
 959     break;
 960   }
 961
 962   DBG2(r,"convert width=[%d --> %d]", oldw, neww);
 963   DBG2(r,"convert heigh=[%d --> %d]", oldh, newh);
 964
 965   MagickResetIterator(magick_wand);
 966
 967   while (MagickNextImage(magick_wand) != MagickFalse) {
 968     switch (mode) {
 969     case IMG_CONV_MODE_WALLPAPER:
 970     case IMG_CONV_MODE_EZGET:
 971
 972       if (MagickResizeImage(magick_wand,neww,newh,LanczosFilter,1.0) == MagickFalse) {
 973         EXIT_MAGICK_ERROR();
 974         return NULL;
 975       }
 976
 977       if (MagickCropImage(magick_wand,
 978                       (unsigned long)c_width,
 979                       (unsigned long)c_heigh,
 980                       (long)((neww - c_width) / 2),
 981                       (long)((newh - c_heigh) / 2)) == MagickFalse) {
 982         EXIT_MAGICK_ERROR();
 983         return NULL;
 984       }
 985       break;
 986
 987     case IMG_CONV_MODE_NORMAL:
 988       if (qsp->width) {
 989         DBG2(r,"convert width=[%d --> %d]", neww, qsp->width);
 990         neww = qsp->width;
 991       }
 992       if (qsp->height) {
 993         DBG2(r,"convert heigh=[%d --> %d]", newh, qsp->height);
 994         newh = qsp->height;
 995       }
 996
 997     default:
 998       if (MagickResizeImage(magick_wand,neww,newh,LanczosFilter,1.0) == MagickFalse) {
 999         EXIT_MAGICK_ERROR();
1000         return NULL;
1001       }
1002       break;
1003     }
1004
1005     if (MagickSetImageUnits(magick_wand, PixelsPerInchResolution) == MagickFalse) {
1006       EXIT_MAGICK_ERROR();
1007       return NULL;
1008     }
1009
1010     if (MagickSetImageResolution(magick_wand,
1011                                  (double)spec->dpi_width,
1012                                  (double)spec->dpi_heigh) == MagickFalse) {
1013       EXIT_MAGICK_ERROR();
1014       return NULL;
1015     }
1016
1017     if (MagickSetImageDispose(magick_wand, BackgroundDispose) == MagickFalse) {
1018       EXIT_MAGICK_ERROR();
1019       return NULL;
1020     }
1021   }
1022
1023   return magick_wand;
1024 }
1025
1026 static MagickWand*
1027 s_fixup_color(MagickWand* magick_wand, request_rec* r, device_table* spec, img_conv_mode_t mode)
1028 {
1029   DBG(r,"start chxj_fixup_clor()");
1030
1031   if (spec->color >= 256) {
1032
1033     DBG1(r,"call MagickQuantizeImage() spec->color=[%d]",spec->color);
1034
1035     if (MagickQuantizeImage(magick_wand,
1036                            spec->color,
1037                            RGBColorspace,
1038                            0,
1039                            1,
1040                            0) == MagickFalse) {
1041       EXIT_MAGICK_ERROR();
1042       return NULL;
1043     }
1044
1045     DBG1(r,"call end MagickQuantizeImage() spec->color=[%d]",spec->color);
1046
1047   }
1048   else {
1049     DBG1(r,"call MagickQuantizeImage() spec->color=[%d]",spec->color);
1050
1051     if (MagickQuantizeImage(magick_wand,
1052                            spec->color,
1053                            GRAYColorspace,
1054                            0,
1055                            1,
1056                            0) == MagickFalse) {
1057       EXIT_MAGICK_ERROR();
1058       return NULL;
1059     }
1060
1061     DBG1(r,"call end MagickQuantizeImage() spec->color=[%d]",spec->color);
1062   }
1063
1064
1065   DBG(r,"end chxj_fixup_clor()");
1066
1067   return magick_wand;
1068 }
1069
1070
1071
1072 static MagickWand*
1073 s_fixup_depth(MagickWand* magick_wand, request_rec* r, device_table* spec)
1074 {
1075   if (spec->color == 15680000) {
1076     if (MagickSetImageDepth(magick_wand, 24) == MagickFalse) {
1077       EXIT_MAGICK_ERROR();
1078       return NULL;
1079     }
1080   }
1081   else
1082   if (spec->color == 262144) {
1083     if (MagickSetImageDepth(magick_wand, 18) == MagickFalse) {
1084       EXIT_MAGICK_ERROR();
1085       return NULL;
1086     }
1087   }
1088   else
1089   if (spec->color == 65536) {
1090     if (MagickSetImageDepth(magick_wand, 16) == MagickFalse) {
1091       EXIT_MAGICK_ERROR();
1092       return NULL;
1093     }
1094   }
1095   else
1096   if (spec->color == 4096) {
1097     if (MagickSetImageDepth(magick_wand, 12) == MagickFalse) {
1098       EXIT_MAGICK_ERROR();
1099       return NULL;
1100     }
1101   }
1102   else
1103   if (spec->color == 256) {
1104     if (MagickSetImageDepth(magick_wand, 8) == MagickFalse) {
1105       EXIT_MAGICK_ERROR();
1106       return NULL;
1107     }
1108   }
1109   else
1110   if (spec->color == 4) {
1111     if (MagickSetImageDepth(magick_wand, 2) == MagickFalse) {
1112       EXIT_MAGICK_ERROR();
1113       return NULL;
1114     }
1115   }
1116   else
1117   if (spec->color == 2) {
1118     if (MagickSetImageDepth(magick_wand, 1) == MagickFalse) {
1119       EXIT_MAGICK_ERROR();
1120       return NULL;
1121     }
1122   }
1123
1124   return magick_wand;
1125 }
1126
1127
1128 static MagickWand*
1129 s_add_copyright(MagickWand* magick_wand, request_rec* r, device_table* spec)
1130 {
1131   mod_chxj_config* conf = ap_get_module_config(r->per_dir_config, &chxj_module);
1132
1133   if (conf->image_copyright) {
1134
1135     DBG1(r, "Add COPYRIGHT [%s]", conf->image_copyright);
1136
1137     if (spec->html_spec_type == CHXJ_SPEC_Jhtml) {
1138       apr_table_setn(r->headers_out, "x-jphone-copyright", "no-transfer");
1139       if (MagickCommentImage(magick_wand,
1140                              apr_psprintf(r->pool,
1141                                           "Copyright(C) %s",
1142                                           conf->image_copyright)) == MagickFalse)
1143         goto on_error;
1144     }
1145     else
1146     if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
1147     ||  spec->html_spec_type == CHXJ_SPEC_Hdml) {
1148       if (MagickCommentImage(magick_wand,
1149                              apr_psprintf(r->pool,
1150                                          "kddi_copyright=on,%s",
1151                                           conf->image_copyright)) == MagickFalse)
1152         goto on_error;
1153     }
1154     else {
1155       if (MagickCommentImage(magick_wand,
1156                             apr_psprintf(r->pool,
1157                                          "copy=\"NO\",%s",
1158                                          conf->image_copyright)) == MagickFalse)
1159         goto on_error;
1160     }
1161   }
1162   else {
1163     if (MagickCommentImage(magick_wand, "mod_chxj") == MagickFalse)
1164       goto on_error;
1165   }
1166   return magick_wand;
1167
1168 on_error:
1169   EXIT_MAGICK_ERROR();
1170   return NULL;
1171 }
1172
1173 static MagickWand*
1174 s_img_down_sizing(MagickWand* magick_wand, request_rec* r, device_table* spec)
1175 {
1176   MagickBooleanType  status;
1177   unsigned long quality = 70;
1178   apr_size_t    writebyte = 0;
1179   char*         writedata;
1180   apr_size_t    prev_size = 0;
1181   int           revers_flag = 0;
1182
1183   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1184   prev_size = writebyte;
1185
1186   do {
1187     if (MagickSetImageCompressionQuality(magick_wand, quality) == MagickFalse) {
1188       EXIT_MAGICK_ERROR();
1189       return NULL;
1190     }
1191
1192     writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1193     if (writebyte >= prev_size || revers_flag) {
1194       DBG2(r, "quality=[%ld] size=[%d]", (long)quality, writebyte);
1195       revers_flag = 1;
1196       quality += 10;
1197       if (quality > 100) {
1198         if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
1199           EXIT_MAGICK_ERROR();
1200           return NULL;
1201         }
1202         break;
1203       }
1204       prev_size = writebyte;
1205       continue;
1206     }
1207
1208     DBG2(r, "quality=[%ld] size=[%d]", (long)quality, writebyte);
1209
1210     if (spec->cache == 0)
1211       break;
1212
1213     if (writebyte <= spec->cache)
1214       break;
1215
1216     quality -= 10;
1217
1218     if (quality == 0 || quality > 100)
1219       break;
1220
1221   }
1222   while (1);
1223
1224
1225   if (spec->cache > 0
1226   &&  writebyte   > spec->cache) {
1227     unsigned long now_color = spec->color;
1228     unsigned long depth     = 0;
1229     do {
1230       switch(now_color) {
1231       case 2:      depth = 1; break;
1232       case 4:      now_color = 2;        depth = 1;  break;
1233       case 8:      now_color = 4;        depth = 2;  break;
1234       case 16:     now_color = 8;        depth = 3;  break;
1235       case 256:    now_color = 16;       depth = 4;  break;
1236       case 4096:   now_color = 256;      depth = 8;  break;
1237       case 65536:  now_color = 4096;     depth = 12; break;
1238       case 262144: now_color = 65536;    depth = 16; break;
1239       case 15680000: now_color = 262144; depth = 18; break;
1240       default:
1241         now_color = 2;
1242         break;
1243       }
1244
1245       if (now_color <= 2) break;
1246
1247       if (now_color >= 8) {
1248         status = MagickQuantizeImage(magick_wand,
1249                              now_color,
1250                              RGBColorspace,
1251                              0,
1252                              1,
1253                              0);
1254       }
1255       else {
1256         status = MagickQuantizeImage(magick_wand,
1257                              now_color,
1258                              GRAYColorspace,
1259                              0,
1260                              1,
1261                              0);
1262         MagickSetImageType(magick_wand, GrayscaleType);
1263       }
1264       if (status == MagickFalse) {
1265         EXIT_MAGICK_ERROR();
1266         return NULL;
1267       }
1268
1269       if (MagickSetImageDepth(magick_wand, depth) == MagickFalse) {
1270         EXIT_MAGICK_ERROR();
1271         return NULL;
1272       }
1273
1274       writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1275
1276       DBG2(r,"now_color=[%ld] size=[%d]", (long)now_color, writebyte);
1277
1278       /* Once per request */
1279       break;
1280     }
1281     while(now_color > 2);
1282   }
1283
1284   return magick_wand;
1285 }
1286
1287 static apr_status_t
1288 s_send_cache_file(device_table* spec, query_string_param_t* query_string, request_rec* r, const char* tmpfile)
1289 {
1290   apr_status_t rv;
1291   apr_finfo_t  st;
1292   apr_file_t*  fout;
1293   apr_size_t   sendbyte;
1294   char*        contentLength;
1295
1296   rv = apr_stat(&st, tmpfile, APR_FINFO_MIN, r->pool);
1297   if (rv != APR_SUCCESS)
1298     return HTTP_NOT_FOUND;
1299
1300   DBG1(r, "mode:[%d]",    query_string->mode);
1301   DBG1(r, "name:[%s]",    query_string->name);
1302   DBG1(r, "offset:[%ld]", query_string->offset);
1303   DBG1(r, "count:[%ld]",  query_string->count);
1304
1305   if (spec->available_jpeg) {
1306     r->content_type = apr_psprintf(r->pool, "image/jpeg");
1307   }
1308   else
1309   if (spec->available_png) {
1310     r->content_type = apr_psprintf(r->pool, "image/png");
1311   }
1312   else
1313   if (spec->available_gif) {
1314     r->content_type = apr_psprintf(r->pool, "image/gif");
1315   }
1316   else
1317   if (spec->available_bmp2 || spec->available_bmp4) {
1318     r->content_type = apr_psprintf(r->pool, "image/bmp");
1319   }
1320
1321   if (query_string->mode != IMG_CONV_MODE_EZGET && query_string->name == NULL) {
1322     contentLength = apr_psprintf(r->pool, "%d", (int)st.size);
1323     apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1324
1325     DBG1(r,"Content-Length:[%d]", (int)st.size);
1326
1327     rv = apr_file_open(&fout, tmpfile,
1328       APR_READ | APR_BINARY, APR_OS_DEFAULT, r->pool);
1329     if (rv != APR_SUCCESS) {
1330       DBG1(r, "tmpfile open failed[%s]", tmpfile);
1331       return HTTP_NOT_FOUND;
1332     }
1333
1334     ap_send_fd(fout, r, 0, st.size, &sendbyte);
1335     apr_file_close(fout);
1336     ap_rflush(r);
1337     DBG1(r, "send file data[%d]byte", sendbyte);
1338   }
1339   else
1340   if (query_string->mode == IMG_CONV_MODE_EZGET) {
1341     char* name = apr_pstrdup(r->pool, basename(r->filename));
1342     name[strlen(name)-4] = 0;
1343     if (strcasecmp(r->content_type, "image/jpeg") == 0) {
1344
1345       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1346       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".jpg", (long)st.size, "devjaww", name);
1347     }
1348     else
1349     if (strcasecmp(r->content_type, "image/bmp") == 0) {
1350       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1351       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".bmp", (long)st.size, "devabm", name);
1352     }
1353     else
1354     if (strcasecmp(r->content_type, "image/png") == 0) {
1355       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1356       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".png", (long)st.size, "dev8aww", name);
1357     }
1358     else
1359     if (strcasecmp(r->content_type, "image/gif") == 0) {
1360       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1361       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".gif", (long)st.size, "devgi0z", name);
1362     }
1363   }
1364   else
1365   if (query_string->mode == IMG_CONV_MODE_WALLPAPER && query_string->name != NULL) {
1366     if (query_string->count == -1 && query_string->offset == -1) {
1367       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1368       ap_rprintf(r, HDML_SUCCESS_PAGE);
1369       ap_rflush(r);
1370     }
1371     else
1372     if (query_string->count == -2 && query_string->offset == -1) {
1373       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1374       ap_rprintf(r, HDML_FAIL_PAGE);
1375       ap_rflush(r);
1376     }
1377     else {
1378       ap_set_content_type(r, "application/x-up-download");
1379       contentLength = apr_psprintf(r->pool, "%ld", query_string->count);
1380       apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1381
1382       DBG1(r, "Content-Length:[%d]", (int)st.size);
1383
1384       rv = apr_file_open(&fout, tmpfile,
1385         APR_READ | APR_BINARY, APR_OS_DEFAULT, r->pool);
1386
1387       if (rv != APR_SUCCESS) {
1388         DBG1(r,"tmpfile open failed[%s]", tmpfile);
1389         return HTTP_NOT_FOUND;
1390       }
1391
1392       ap_send_fd(fout, r, query_string->offset, query_string->count, &sendbyte);
1393       apr_file_close(fout);
1394       ap_rflush(r);
1395       DBG1(r, "send file data[%d]byte", sendbyte);
1396     }
1397   }
1398
1399   return OK;
1400 }
1401
1402 static apr_status_t
1403 s_header_only_cache_file(device_table* spec, query_string_param_t* query_string, request_rec* r, const char* tmpfile)
1404 {
1405   apr_status_t rv;
1406   apr_finfo_t  st;
1407   char*        contentLength;
1408
1409   rv = apr_stat(&st, tmpfile, APR_FINFO_MIN, r->pool);
1410   if (rv != APR_SUCCESS)
1411     return HTTP_NOT_FOUND;
1412
1413   DBG1(r, "mode:[%d]",    query_string->mode);
1414   DBG1(r, "name:[%s]",    query_string->name);
1415   DBG1(r, "offset:[%ld]", query_string->offset);
1416   DBG1(r, "count:[%ld]",  query_string->count);
1417
1418   if (spec->available_jpeg) {
1419     r->content_type = apr_psprintf(r->pool, "image/jpeg");
1420   }
1421   else
1422   if (spec->available_png) {
1423     r->content_type = apr_psprintf(r->pool, "image/png");
1424   }
1425   else
1426   if (spec->available_gif) {
1427     r->content_type = apr_psprintf(r->pool, "image/gif");
1428   }
1429   else
1430   if (spec->available_bmp2 || spec->available_bmp4) {
1431     r->content_type = apr_psprintf(r->pool, "image/bmp");
1432   }
1433
1434   if (query_string->mode != IMG_CONV_MODE_EZGET && query_string->name == NULL) {
1435     contentLength = apr_psprintf(r->pool, "%d", (int)st.size);
1436     apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1437
1438     DBG1(r,"Content-Length:[%d]", (int)st.size);
1439   }
1440   else
1441   if (query_string->mode == IMG_CONV_MODE_EZGET) {
1442     char* name = apr_pstrdup(r->pool, basename(r->filename));
1443     name[strlen(name)-4] = 0;
1444     if (strcasecmp(r->content_type, "image/jpeg") == 0) {
1445
1446       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1447     }
1448     else
1449     if (strcasecmp(r->content_type, "image/bmp") == 0) {
1450       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1451     }
1452     else
1453     if (strcasecmp(r->content_type, "image/png") == 0) {
1454       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1455     }
1456     else
1457     if (strcasecmp(r->content_type, "image/gif") == 0) {
1458       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1459     }
1460   }
1461   else
1462   if (query_string->mode == IMG_CONV_MODE_WALLPAPER && query_string->name != NULL) {
1463     if (query_string->count == -1 && query_string->offset == -1) {
1464       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1465     }
1466     else
1467     if (query_string->count == -2 && query_string->offset == -1) {
1468       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1469     }
1470     else {
1471       ap_set_content_type(r, "application/x-up-download");
1472       contentLength = apr_psprintf(r->pool, "%ld", query_string->count);
1473       apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1474
1475       DBG1(r, "Content-Length:[%d]", (int)st.size);
1476     }
1477   }
1478
1479   return OK;
1480 }
1481
1482
1483
1484 static char*
1485 s_create_workfile(
1486                 request_rec*          r,
1487                 mod_chxj_config*      conf,
1488                 const char*           user_agent,
1489                 query_string_param_t *qsp)
1490 {
1491   int ii;
1492   int jj;
1493   int len;
1494   char* w = apr_palloc(r->pool, 256);
1495   char* fname;
1496
1497   memset(w, 0, 256);
1498   switch (qsp->mode) {
1499   case IMG_CONV_MODE_THUMBNAIL:
1500     fname = apr_psprintf(r->pool, "%s.%s.thumbnail", r->filename, user_agent);
1501     DBG1(r, "mode=thumbnail [%s]", fname);
1502     break;
1503   case IMG_CONV_MODE_WALLPAPER:
1504   case IMG_CONV_MODE_EZGET:
1505     fname = apr_psprintf(r->pool, "%s.%s.wallpaper", r->filename, user_agent);
1506     DBG1(r, "mode=WallPaper [%s]", fname);
1507     break;
1508   case IMG_CONV_MODE_NORMAL:
1509   default:
1510
1511     fname = apr_psprintf(r->pool, "%s.%s", r->filename, user_agent);
1512
1513     if (qsp->width)
1514       fname = apr_psprintf(r->pool, "%s.w%d", fname, qsp->width);
1515
1516     if (qsp->height)
1517       fname = apr_psprintf(r->pool, "%s.h%d", fname, qsp->height);
1518
1519     DBG1(r,"mode=normal [%s]", fname);
1520     break;
1521   }
1522   if (qsp->ua_flag == UA_IGN) {
1523     fname = apr_psprintf(r->pool, "%s.IGN", fname);
1524   }
1525
1526   len = strlen(fname);
1527   jj=0;
1528   for  (ii=0; ii<len; ii++) {
1529     if (fname[ii] == '/'
1530     ||  fname[ii] == ' '
1531     ||  fname[ii] == '-'
1532     ||  fname[ii] == '('
1533     ||  fname[ii] == ')') {
1534       w[jj++] = '_';
1535     }
1536     else {
1537       w[jj++] = fname[ii];
1538     }
1539   }
1540
1541   return apr_psprintf(r->pool, "%s/%s", conf->image_cache_dir,w);
1542 }
1543
1544 static unsigned short
1545 s_add_crc(const char* writedata, apr_size_t writebyte)
1546 {
1547   unsigned short crc = 0xffff;
1548   apr_size_t     ii;
1549   unsigned char  ch;
1550
1551   for(ii=0;ii<writebyte;ii++) {
1552     ch  = writedata[ii];
1553     crc = AU_CRC_TBL[(crc>>8^ch)&0xff]^(crc<<8);
1554   }
1555   return crc;
1556 }
1557
1558 int
1559 chxj_trans_name(request_rec *r)
1560 {
1561   const char* ccp;
1562   char* docroot;
1563   int len;
1564   apr_finfo_t st;
1565   apr_status_t rv;
1566   mod_chxj_config* conf;
1567   int ii;
1568   char*      ext[] = {
1569           "jpg",
1570           "jpeg",
1571           "png",
1572           "bmp",
1573           "gif",
1574           "qrc",    /* QRCode½ÐÎÏÍÑ¥Õ¥¡¥¤¥ë¤Î³ÈÄ¥»Ò */
1575           "",
1576   };
1577   char*    fname;
1578   char*    idx;
1579   char*    filename_sv;
1580   int      do_ext_check = TRUE;
1581   int      next_ok      = FALSE;
1582
1583   DBG(r, "start chxj_trans_name()");
1584
1585   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
1586
1587   if (conf == NULL) {
1588     DBG1(r, "end chxj_trans_name() conf is null[%s]", r->uri);
1589     return DECLINED;
1590   }
1591
1592   if (conf->image != CHXJ_IMG_ON) {
1593     DBG(r, "end chxj_trans_name() conf not found");
1594     return DECLINED;
1595   }
1596
1597
1598   DBG1(r,"Match URI[%s]", r->uri);
1599
1600
1601   if (r->filename == NULL)
1602     r->filename = apr_pstrdup(r->pool, r->uri);
1603
1604   filename_sv = NULL;
1605   if ((idx = strchr(r->filename, ':')) != NULL)
1606     filename_sv = idx+1;
1607   else
1608     filename_sv = r->filename;
1609
1610   DBG1(r,"r->filename[%s]", filename_sv);
1611
1612   ccp = ap_document_root(r);
1613   if (ccp == NULL)
1614     return HTTP_INTERNAL_SERVER_ERROR;
1615
1616   docroot = apr_pstrdup(r->pool, ccp);
1617   len = strlen(docroot);
1618
1619   if (docroot[len-1] == '/')
1620     docroot[len-1] = '\0';
1621
1622
1623   if (r->server->path
1624   &&  *filename_sv == *r->server->path
1625   &&  strncmp(filename_sv, r->server->path, r->server->pathlen) == 0)
1626     filename_sv = apr_pstrcat(r->pool, docroot, (filename_sv + r->server->pathlen), NULL);
1627   else
1628     filename_sv = apr_pstrcat(r->pool, docroot, filename_sv, NULL);
1629
1630   DBG1(r,"URI[%s]", filename_sv);
1631
1632   do_ext_check = TRUE;
1633   for (ii=0; ii<7-1; ii++) {
1634     char* pos = strrchr(filename_sv, '.');
1635     if (pos && pos++) {
1636       if (strcasecmp(pos, ext[ii]) == 0) {
1637         do_ext_check = FALSE;
1638         fname = apr_psprintf(r->pool, "%s", filename_sv);
1639         break;
1640       }
1641     }
1642   }
1643
1644   if (do_ext_check) {
1645     for (ii=0; ii<7; ii++) {
1646       if (strlen(ext[ii]) == 0) {
1647         fname = apr_psprintf(r->pool, "%s", filename_sv);
1648       }
1649       else
1650         fname = apr_psprintf(r->pool, "%s.%s", filename_sv, ext[ii]);
1651
1652       DBG1(r,"search [%s]", fname);
1653
1654       rv = apr_stat(&st, fname, APR_FINFO_MIN, r->pool);
1655       if (rv == APR_SUCCESS) {
1656         if (st.filetype != APR_DIR)
1657           break;
1658       }
1659
1660       fname = NULL;
1661     }
1662   }
1663   if (fname == NULL) {
1664     DBG1(r,"NotFound [%s]", r->filename);
1665     return DECLINED;
1666   }
1667   for (ii=0; ii<7-1; ii++) {
1668     char* pos = strrchr(fname, '.');
1669     if (pos && pos++) {
1670       if (strcasecmp(pos, ext[ii]) == 0) {
1671         next_ok = TRUE;
1672         break;
1673       }
1674     }
1675   }
1676
1677   if (! next_ok)  {
1678     DBG1(r,"NotFound [%s]", r->filename);
1679     return DECLINED;
1680   }
1681
1682   if (r->handler == NULL || strcasecmp(r->handler, "chxj-qrcode") != 0) {
1683     DBG1(r,"Found [%s]", fname);
1684
1685     r->filename = apr_psprintf(r->pool, "%s", fname);
1686
1687     if (strcasecmp("qrc", ext[ii]) == 0)
1688       r->handler = apr_psprintf(r->pool, "chxj-qrcode");
1689     else
1690       r->handler = apr_psprintf(r->pool, "chxj-picture");
1691   }
1692   DBG(r, "end chxj_trans_name()");
1693   return OK;
1694 }
1695
1696
1697
1698 /**
1699  * It converts it from QUERYSTRING.
1700  *
1701  * @param r   [i]
1702  */
1703 static query_string_param_t*
1704 s_get_query_string_param(request_rec *r)
1705 {
1706   char* pair;
1707   char* name;
1708   char* value;
1709   char* pstate;
1710   char* vstate;
1711   char* s;
1712   query_string_param_t* param;
1713
1714   s = apr_pstrdup(r->pool, r->parsed_uri.query);
1715   param = apr_palloc(r->pool, sizeof(query_string_param_t));
1716   param->mode       = IMG_CONV_MODE_NORMAL;
1717   param->user_agent = NULL;
1718   param->ua_flag    = UA_USE;
1719   param->name       = NULL;
1720   param->offset     = 0;
1721   param->count      = 0;
1722   param->width      = 0;
1723   param->height     = 0;
1724
1725   if (s == NULL) return param;
1726
1727   for (;;) {
1728     if ((pair = apr_strtok(s, "&", &pstate)) == NULL) break;
1729     s = NULL;
1730
1731     name  = apr_strtok(pair, "=", &vstate);
1732     value = apr_strtok(NULL, "=", &vstate);
1733
1734     switch (*name) {
1735     case 'm':
1736     case 'M':
1737       if (value && (strcasecmp(name, "mode") == 0 || strcasecmp(name, "m") == 0)) {
1738
1739         switch (*value) {
1740         case 't':
1741         case 'T':
1742           if (strcasecmp(value, "thumbnail") == 0 || strcasecmp(value, "tb") == 0)
1743             param->mode = IMG_CONV_MODE_THUMBNAIL;
1744           break;
1745
1746         case 'w':
1747         case 'W':
1748           if (strcasecmp(value, "WP") == 0 || strcasecmp(value, "WallPaper") == 0)
1749             param->mode = IMG_CONV_MODE_WALLPAPER;
1750           break;
1751
1752         case 'e':
1753         case 'E':
1754           if (strcasecmp(value, "EZGET") == 0)
1755             param->mode = IMG_CONV_MODE_EZGET;
1756           break;
1757         default:
1758           break;
1759         }
1760       }
1761       break;
1762
1763     case 'u':
1764     case 'U':
1765       if (value && (strcasecmp(name, "ua") == 0 || strcasecmp(name, "user-agent") == 0)) {
1766         ap_unescape_url(value);
1767
1768         if ((*value == 'i' || *value == 'I') && strcasecmp(value, "IGN") == 0)
1769           param->ua_flag = UA_IGN;
1770
1771         param->user_agent = apr_pstrdup(r->pool, value);
1772       }
1773       break;
1774
1775     case 'n':
1776     case 'N':
1777       if (value && strcasecmp(name, "name") == 0)
1778         param->name = apr_pstrdup(r->pool, value);
1779       break;
1780
1781     case 'o':
1782     case 'O':
1783       if (value && strcasecmp(name, "offset") == 0 && (! chxj_chk_numeric(value)))
1784         param->offset = chxj_atoi(value);
1785
1786       break;
1787
1788     case 'c':
1789     case 'C':
1790       if (value && strcasecmp(name, "count") == 0 && (! chxj_chk_numeric(value)))
1791         param->count = chxj_atoi(value);
1792       break;
1793
1794     case 'w':
1795     case 'W':
1796       if (value && strcasecmp(name, "w") == 0 && (! chxj_chk_numeric(value)))
1797         param->width = chxj_atoi(value);
1798       break;
1799
1800     case 'h':
1801     case 'H':
1802       if (value && strcasecmp(name, "h") == 0 && (! chxj_chk_numeric(value)))
1803         param->height = chxj_atoi(value);
1804       break;
1805
1806     default:
1807       break;
1808     }
1809   }
1810
1811   if (param->mode == IMG_CONV_MODE_NORMAL && param->name)
1812     param->mode = IMG_CONV_MODE_WALLPAPER;
1813
1814   return param;
1815 }
1816 /*
1817  * vim:ts=2 et
1818  */