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*, mod_chxj_config* ,
 165                                         const char*,
 166                                         query_string_param_t*);
 167 static apr_status_t s_create_cache_file(request_rec* r,
 168                                         const char* tmpfile,
 169                                         device_table* spec,
 170                                         apr_finfo_t* st,
 171                                         query_string_param_t *qsp);
 172 static apr_status_t s_send_cache_file(  device_table* spec,
 173                                         query_string_param_t* query_string,
 174                                         request_rec* r,
 175                                         const char* tmpfile);
 176 static apr_status_t s_header_only_cache_file(
 177   device_table* spec,
 178   query_string_param_t* query_string,
 179   request_rec* r,
 180   const char* tmpfile);
 181 static query_string_param_t* s_get_query_string_param(request_rec *r);
 182 static unsigned short s_add_crc(        const char* writedata,
 183                                         apr_size_t witebyte);
 184 static MagickWand* s_fixup_size(MagickWand* ,
 185                                         request_rec* r,
 186                                         device_table* spec,
 187                                         query_string_param_t *qsp);
 188 static MagickWand* s_fixup_color(MagickWand* magick_wand,
 189                                  request_rec* r,
 190                                  device_table* spec,
 191                                  img_conv_mode_t mode);
 192 static MagickWand* s_fixup_depth(MagickWand* magick_wand,
 193                                  request_rec* r, device_table* spec);
 194 static MagickWand* s_img_down_sizing(MagickWand* magick_wand,
 195                                 request_rec* r, device_table* spec);
 196 static MagickWand* s_add_copyright(
 197                           MagickWand* magick_wand,
 198                           request_rec* r,
 199                           device_table* spec);
 200 static char* s_create_blob_data(request_rec* r,
 201                    device_table* spec,
 202                    query_string_param_t *qsp,
 203                    char* indata,
 204                    apr_size_t* len);
 205
 206 static int s_img_conv_format_from_file(
 207                 request_rec*          r,
 208                 mod_chxj_config*    conf,
 209                 const char*           user_agent,
 210                 query_string_param_t* qsp,
 211                 device_table*       spec);
 212
 213 int
 214 chxj_img_conv_format_handler(request_rec* r)
 215 {
 216   mod_chxj_config*      conf;
 217   query_string_param_t* qsp;
 218   char*                 user_agent;
 219   device_table*       spec;
 220   chxjconvrule_entry* entryp;
 221
 222   DBG(r, "start chxj_img_conv_format_handler()");
 223
 224   if ((*r->handler != 'c' && *r->handler != 'C')
 225   ||  (strcasecmp(r->handler, "chxj-picture")
 226   &&  strcasecmp(r->handler, "chxj-qrcode"))) {
 227     DBG(r, "end chxj_img_conv_format_handler()");
 228     return DECLINED;
 229   }
 230
 231   qsp = s_get_query_string_param(r);
 232   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
 233   if (conf == NULL) {
 234     DBG(r, "end chxj_img_conv_format_handler() conf is null");
 235     return DECLINED;
 236   }
 237
 238   if (strcasecmp(r->handler, "chxj-qrcode") == 0 &&  conf->image == CHXJ_IMG_OFF)
 239     return DECLINED;
 240
 241
 242   /*------------------------------------------------------------------------*/
 243   /* get UserAgent from http header                                         */
 244   /*------------------------------------------------------------------------*/
 245   /*--------------------------------------------------------------------------*/
 246   /* User-Agent to spec                                                       */
 247   /*--------------------------------------------------------------------------*/
 248   if (qsp->user_agent) {
 249     user_agent = apr_pstrdup(r->pool, qsp->user_agent);
 250   }
 251   else {
 252     entryp = chxj_apply_convrule(r, conf->convrules);
 253     if (entryp && entryp->user_agent) {
 254       user_agent = (char*)apr_table_get(r->headers_in, CHXJ_HTTP_USER_AGENT);
 255     }
 256     else {
 257       user_agent = (char*)apr_table_get(r->headers_in, HTTP_USER_AGENT);
 258     }
 259   }
 260
 261
 262
 263   if (qsp->ua_flag == UA_IGN)
 264     spec = &v_ignore_spec;
 265   else
 266     spec = chxj_specified_device(r, user_agent);
 267
 268   DBG1(r,"found device_name=[%s]", spec->device_name);
 269   DBG1(r,"User-Agent=[%s]", user_agent);
 270
 271   if (spec->width == 0 || spec->heigh == 0)
 272     return DECLINED;
 273
 274   return s_img_conv_format_from_file(r, conf, user_agent, qsp, spec);
 275 }
 276
 277
 278
 279 /**
 280  * It converts it from ImageData corresponding to each model.
 281  *
 282  * @param r   [i]
 283  * @param src [i]   It is former image binary data.
 284  * @param len [i/o] It is length of former image binary data.
 285  */
 286 char*
 287 chxj_exchange_image(request_rec *r, const char** src, apr_size_t* len)
 288 {
 289   mod_chxj_config*      conf;
 290   query_string_param_t* qsp;
 291   char*                 user_agent;
 292   device_table*         spec;
 293   char*                 dst;
 294   char*                 conv_check;
 295   chxjconvrule_entry* entryp;
 296
 297   DBG(r, "start chxj_exchange_image()");
 298
 299   conv_check = (char*)apr_table_get(r->headers_in, "CHXJ_IMG_CONV");
 300   if (conv_check) {
 301     DBG(r, "end chxj_exchnage_image() already convert.");
 302     return NULL;
 303   }
 304
 305
 306   qsp = s_get_query_string_param(r);
 307   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
 308   if (conf == NULL) {
 309     DBG(r, "end chxj_exchange_image()");
 310     return NULL;
 311   }
 312
 313   /*--------------------------------------------------------------------------*/
 314   /* User-Agent to spec                                                       */
 315   /*--------------------------------------------------------------------------*/
 316   if (qsp->user_agent) {
 317     user_agent = apr_pstrdup(r->pool, qsp->user_agent);
 318   }
 319   else {
 320     entryp = chxj_apply_convrule(r, conf->convrules);
 321     if (entryp && entryp->user_agent) {
 322       user_agent = (char*)apr_table_get(r->headers_in, CHXJ_HTTP_USER_AGENT);
 323     }
 324     else {
 325       user_agent = (char*)apr_table_get(r->headers_in, HTTP_USER_AGENT);
 326     }
 327   }
 328
 329   if (qsp->ua_flag == UA_IGN)
 330     spec = &v_ignore_spec;
 331   else
 332     spec = chxj_specified_device(r, user_agent);
 333
 334   DBG1(r,"found device_name=[%s]", spec->device_name);
 335   DBG1(r, "User-Agent=[%s]", user_agent);
 336
 337   if (spec->width == 0 || spec->heigh == 0)
 338     return NULL;
 339
 340   dst = s_create_blob_data(r, spec, qsp, (char*)*src, len);
 341   if (dst == NULL)
 342     *len = 0;
 343
 344   DBG(r, "end chxj_exchange_image()");
 345
 346   return dst;
 347 }
 348
 349 static int
 350 s_img_conv_format_from_file(
 351                 request_rec*          r,
 352                 mod_chxj_config*    conf,
 353                 const char*           user_agent,
 354                 query_string_param_t* qsp,
 355                 device_table*       spec)
 356 {
 357   apr_status_t   rv;
 358   apr_finfo_t    st;
 359   apr_finfo_t    cache_st;
 360   char*          tmpfile;
 361
 362   /*--------------------------------------------------------------------------*/
 363   /* Create Workfile Name                                                     */
 364   /*--------------------------------------------------------------------------*/
 365   tmpfile = s_create_workfile(r, conf, user_agent, qsp);
 366   DBG1(r,"workfile=[%s]", tmpfile);
 367
 368   rv = apr_stat(&st, r->filename, APR_FINFO_MIN, r->pool);
 369   if (rv != APR_SUCCESS)
 370     return HTTP_NOT_FOUND;
 371
 372
 373   DBG1(r,"found [%s]", r->filename);
 374   rv = apr_stat(&cache_st, tmpfile, APR_FINFO_MIN, r->pool);
 375   DBG1(r,"found [%s]", r->filename);
 376
 377   if (rv != APR_SUCCESS || cache_st.ctime < st.mtime) {
 378     /*------------------------------------------------------------------------*/
 379     /* It tries to make the cash file when it doesn't exist or there is       */
 380     /* change time later since the making time of the cash file.              */
 381     /*------------------------------------------------------------------------*/
 382     rv = s_create_cache_file(r,tmpfile, spec, &st, qsp);
 383     if (rv != OK)
 384       return rv;
 385   }
 386
 387   DBG1(r,"color=[%d]", spec->color);
 388   if (! r->header_only)  {
 389     rv = s_send_cache_file(spec, qsp,r, tmpfile);
 390     if (rv != OK)
 391       return rv;
 392   }
 393   else {
 394     rv = s_header_only_cache_file(spec, qsp, r, tmpfile);
 395     if (rv != OK)
 396       return rv;
 397   }
 398   apr_table_setn(r->headers_in, "CHXJ_IMG_CONV", "done");
 399
 400   DBG(r,"end chxj_img_conv_format");
 401
 402   return OK;
 403 }
 404
 405
 406 static apr_status_t
 407 s_create_cache_file(request_rec*       r,
 408                        const char*     tmpfile,
 409                        device_table* spec,
 410                        apr_finfo_t*    st,
 411                        query_string_param_t *qsp)
 412 {
 413   apr_status_t       rv;
 414   apr_size_t         readbyte;
 415   apr_size_t         writebyte;
 416   unsigned short     crc;
 417   img_conv_mode_t    mode = qsp->mode;
 418
 419   char*              writedata = NULL;
 420   char*              readdata  = NULL;
 421
 422   apr_file_t*        fout;
 423   apr_file_t*        fin;
 424
 425   MagickWand*        magick_wand;
 426
 427   if ((*r->handler == 'c' || *r->handler == 'C')
 428   &&  strcasecmp(r->handler, "chxj-qrcode") == 0) {
 429     /*------------------------------------------------------------------------*/
 430     /* QRCODEÍÑ¤Î¥Õ¥¡¥¤¥ë¤Î¾ì¹ç                                               */
 431     /*------------------------------------------------------------------------*/
 432     Doc       doc;
 433     Node*     root;
 434     qr_code_t qrcode;
 435     int       sts;
 436
 437     memset(&doc,    0, sizeof(Doc));
 438     memset(&qrcode, 0, sizeof(qr_code_t));
 439     doc.r = r;
 440     doc.parse_mode  = PARSE_MODE_CHTML;
 441     qrcode.doc      = &doc;
 442     qrcode.r        = r;
 443
 444     qs_init_malloc(&doc);
 445
 446     root = qs_parse_file(&doc, r->filename);
 447
 448     chxj_qrcode_node_to_qrcode(&qrcode, root);
 449
 450     qs_all_free(&doc,QX_LOGMARK);
 451
 452     sts = chxj_qrcode_create_image_data(&qrcode, &readdata, &readbyte);
 453     if (sts != OK) {
 454       ERR(r, "qrcode create failed.");
 455       return sts;
 456     }
 457   }
 458   else {
 459     /*------------------------------------------------------------------------*/
 460     /* ÄÌ¾ï¤Î¥¤¥á¡¼¥¸¥Õ¥¡¥¤¥ë¤Î¾ì¹ç                                           */
 461     /*------------------------------------------------------------------------*/
 462     rv = apr_file_open(&fin,
 463                     r->filename,
 464                     APR_READ|APR_BINARY ,
 465                     APR_OS_DEFAULT,
 466                     r->pool);
 467     if (rv != APR_SUCCESS) {
 468       DBG1(r,"file open failed.[%s]", r->filename);
 469       return HTTP_NOT_FOUND;
 470     }
 471
 472     readdata = apr_palloc(r->pool, st->size);
 473     rv = apr_file_read_full(fin, (void*)readdata, st->size, &readbyte);
 474     if (rv != APR_SUCCESS || readbyte != st->size) {
 475       DBG1(r,"file read failed.[%s]", r->filename);
 476       apr_file_close(fin);
 477
 478       return HTTP_NOT_FOUND;
 479     }
 480   }
 481   DBG(r,"start img convert");
 482
 483
 484   magick_wand = NewMagickWand();
 485   if (MagickReadImageBlob(magick_wand,readdata, readbyte) == MagickFalse) {
 486     EXIT_MAGICK_ERROR();
 487     return HTTP_NOT_FOUND;
 488   }
 489
 490   /*
 491    * The size of the image is changed.
 492    */
 493   DBG(r,"call s_fixup_size()");
 494
 495   if ((magick_wand = s_fixup_size(magick_wand, r, spec, qsp)) == NULL)
 496     return HTTP_NOT_FOUND;
 497
 498   /*
 499    * The colors of the image is changed.
 500    */
 501   DBG(r,"call s_fixup_color()");
 502
 503   if ((magick_wand = s_fixup_color(magick_wand, r,spec, mode)) == NULL)
 504     return HTTP_NOT_FOUND;
 505
 506   /*
 507    * DEPTH of the image is changed.
 508    */
 509   DBG(r,"call s_fixup_depth()");
 510
 511   if ((magick_wand = s_fixup_depth(magick_wand, r, spec)) == NULL)
 512     return HTTP_NOT_FOUND;
 513
 514
 515
 516   DBG(r,"start convert and compression");
 517
 518   if (spec->available_jpeg) {
 519     if (MagickSetImageCompression(magick_wand,JPEGCompression) == MagickFalse) {
 520       EXIT_MAGICK_ERROR();
 521       return HTTP_NOT_FOUND;
 522     }
 523
 524     if (MagickSetImageFormat(magick_wand, "jpg") == MagickFalse) {
 525       EXIT_MAGICK_ERROR();
 526       return HTTP_NOT_FOUND;
 527     }
 528
 529     if (MagickStripImage(magick_wand) == MagickFalse) {
 530       EXIT_MAGICK_ERROR();
 531       return HTTP_NOT_FOUND;
 532     }
 533
 534     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 535       return HTTP_NOT_FOUND;
 536
 537     r->content_type = apr_psprintf(r->pool, "image/jpeg");
 538     DBG(r,"convert to jpg");
 539   }
 540   else
 541   if (spec->available_png) {
 542
 543     if (MagickSetImageCompression(magick_wand,ZipCompression) == MagickFalse) {
 544       EXIT_MAGICK_ERROR();
 545       return HTTP_NOT_FOUND;
 546     }
 547
 548     if (MagickSetImageFormat(magick_wand, "png") == MagickFalse) {
 549       EXIT_MAGICK_ERROR();
 550       return HTTP_NOT_FOUND;
 551     }
 552
 553     if (MagickStripImage(magick_wand) == MagickFalse) {
 554       EXIT_MAGICK_ERROR();
 555       return HTTP_NOT_FOUND;
 556     }
 557
 558     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 559       return HTTP_NOT_FOUND;
 560
 561     r->content_type = apr_psprintf(r->pool, "image/png");
 562     DBG(r, "convert to png");
 563   }
 564   else
 565   if (spec->available_gif) {
 566
 567     if (MagickSetImageCompression(magick_wand,LZWCompression) == MagickFalse) {
 568       EXIT_MAGICK_ERROR();
 569       return HTTP_NOT_FOUND;
 570     }
 571
 572     if (MagickSetImageFormat(magick_wand, "gif") == MagickFalse) {
 573       EXIT_MAGICK_ERROR();
 574       return HTTP_NOT_FOUND;
 575     }
 576
 577     if (MagickStripImage(magick_wand) == MagickFalse) {
 578       EXIT_MAGICK_ERROR();
 579       return HTTP_NOT_FOUND;
 580     }
 581
 582     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 583       return HTTP_NOT_FOUND;
 584
 585     r->content_type = apr_psprintf(r->pool, "image/gif");
 586
 587     DBG(r,"convert to gif");
 588   }
 589   else
 590   if (spec->available_bmp2 || spec->available_bmp4) {
 591
 592     if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
 593       EXIT_MAGICK_ERROR();
 594       return HTTP_NOT_FOUND;
 595     }
 596
 597     if (MagickSetImageFormat(magick_wand, "bmp") == MagickFalse) {
 598       EXIT_MAGICK_ERROR();
 599       return HTTP_NOT_FOUND;
 600     }
 601
 602     if (MagickStripImage(magick_wand) == MagickFalse) {
 603       EXIT_MAGICK_ERROR();
 604       return HTTP_NOT_FOUND;
 605     }
 606
 607     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 608       return HTTP_NOT_FOUND;
 609
 610     r->content_type = apr_psprintf(r->pool, "image/bmp");
 611
 612     DBG(r, "convert to bmp(unsupported)");
 613   }
 614
 615   /*
 616    * Add Comment (Copyright and so on.)
 617    */
 618   DBG(r, "call s_add_copyright()");
 619
 620   if ((magick_wand = s_add_copyright(magick_wand, r, spec)) == NULL)
 621     return HTTP_NOT_FOUND;
 622
 623   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
 624
 625   if (! writebyte) {
 626     DestroyMagickWand(magick_wand);
 627     ERR1(r,"convert failure to Jpeg [%s]", tmpfile);
 628
 629     return HTTP_INTERNAL_SERVER_ERROR;
 630   }
 631
 632   DBG(r, "end convert and compression");
 633
 634   /* to cache */
 635   rv = apr_file_open(&fout, tmpfile,
 636                   APR_WRITE| APR_CREATE | APR_BINARY | APR_SHARELOCK ,APR_OS_DEFAULT,
 637                   r->pool);
 638   if (rv != APR_SUCCESS) {
 639     DestroyMagickWand(magick_wand);
 640     ERR1(r,"file open error.[%s]", tmpfile);
 641     return HTTP_INTERNAL_SERVER_ERROR;
 642   }
 643
 644   rv = apr_file_write(fout, (void*)writedata, &writebyte);
 645   if (rv != APR_SUCCESS) {
 646     DestroyMagickWand(magick_wand);
 647     apr_file_close(fout);
 648     return HTTP_INTERNAL_SERVER_ERROR;
 649   }
 650
 651   /*
 652    * CRC is added for AU for EzGET.
 653    */
 654   if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
 655   ||  spec->html_spec_type == CHXJ_SPEC_Hdml            ) {
 656
 657     crc = s_add_crc(writedata, writebyte);
 658
 659     rv = apr_file_putc((crc >> 8)  & 0xff, fout);
 660     if (rv != APR_SUCCESS) {
 661       DestroyMagickWand(magick_wand);
 662       return HTTP_INTERNAL_SERVER_ERROR;
 663     }
 664
 665     rv = apr_file_putc( crc        & 0xff, fout);
 666     if (rv != APR_SUCCESS) {
 667       DestroyMagickWand(magick_wand);
 668       return HTTP_INTERNAL_SERVER_ERROR;
 669     }
 670   }
 671
 672   DestroyMagickWand(magick_wand);
 673
 674   rv = apr_file_close(fout);
 675   if (rv != APR_SUCCESS) {
 676     DBG1(r,"file write error.[%s]", tmpfile);
 677     return HTTP_INTERNAL_SERVER_ERROR;
 678   }
 679
 680   return OK;
 681 }
 682
 683
 684 static char*
 685 s_create_blob_data(request_rec* r,
 686                    device_table* spec,
 687                    query_string_param_t *qsp,
 688                    char* indata,
 689                    apr_size_t* len)
 690 {
 691   apr_size_t         writebyte;
 692   unsigned short     crc;
 693   img_conv_mode_t    mode = qsp->mode;
 694
 695   char*              writedata = NULL;
 696   char*              dst       = NULL;
 697
 698   MagickWand*        magick_wand;
 699
 700   magick_wand = NewMagickWand();
 701
 702   if (MagickReadImageBlob(magick_wand,indata, *len) == MagickFalse) {
 703     EXIT_MAGICK_ERROR();
 704     return NULL;
 705   }
 706
 707   /*
 708    * The size of the image is changed.
 709    */
 710   DBG(r, "call s_fixup_size()");
 711
 712   if ((magick_wand = s_fixup_size(magick_wand, r, spec, qsp)) == NULL)
 713     return NULL;
 714
 715   /*
 716    * The colors of the image is changed.
 717    */
 718   DBG(r, "call s_fixup_color()");
 719
 720   if ((magick_wand = s_fixup_color(magick_wand, r,spec, mode)) == NULL)
 721     return NULL;
 722
 723   /*
 724    * DEPTH of the image is changed.
 725    */
 726
 727   DBG(r,"call s_fixup_depth()");
 728
 729   if ((magick_wand = s_fixup_depth(magick_wand, r, spec)) == NULL)
 730     return NULL;
 731
 732
 733
 734   DBG(r,"start convert and compression");
 735
 736   if (spec->available_jpeg) {
 737     if (MagickSetImageCompression(magick_wand,JPEGCompression) == MagickFalse) {
 738       EXIT_MAGICK_ERROR();
 739       return NULL;
 740     }
 741
 742     if (MagickSetImageFormat(magick_wand, "jpg") == MagickFalse) {
 743       EXIT_MAGICK_ERROR();
 744       return NULL;
 745     }
 746
 747     if (MagickStripImage(magick_wand) == MagickFalse) {
 748       EXIT_MAGICK_ERROR();
 749       return NULL;
 750     }
 751
 752     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 753       return NULL;
 754
 755     r->content_type = apr_psprintf(r->pool, "image/jpeg");
 756
 757     DBG(r, "convert to jpg");
 758   }
 759   else
 760   if (spec->available_png) {
 761     if (MagickSetImageCompression(magick_wand,ZipCompression) == MagickFalse) {
 762       EXIT_MAGICK_ERROR();
 763       return NULL;
 764     }
 765
 766     if (MagickSetImageFormat(magick_wand, "png") == MagickFalse) {
 767       EXIT_MAGICK_ERROR();
 768       return NULL;
 769     }
 770
 771     if (MagickStripImage(magick_wand) == MagickFalse) {
 772       EXIT_MAGICK_ERROR();
 773       return NULL;
 774     }
 775
 776     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 777       return NULL;
 778
 779     r->content_type = apr_psprintf(r->pool, "image/png");
 780
 781     DBG(r,"convert to png");
 782   }
 783   else
 784   if (spec->available_gif) {
 785
 786     if (MagickSetImageCompression(magick_wand,LZWCompression) == MagickFalse) {
 787       EXIT_MAGICK_ERROR();
 788       return NULL;
 789     }
 790
 791     if (MagickSetImageFormat(magick_wand, "gif") == MagickFalse) {
 792       EXIT_MAGICK_ERROR();
 793       return NULL;
 794     }
 795
 796     if (MagickStripImage(magick_wand) == MagickFalse) {
 797       EXIT_MAGICK_ERROR();
 798       return NULL;
 799     }
 800
 801     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 802       return NULL;
 803
 804     r->content_type = apr_psprintf(r->pool, "image/gif");
 805
 806     DBG(r,"convert to gif");
 807   }
 808   else
 809   if (spec->available_bmp2 || spec->available_bmp4) {
 810     if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
 811       EXIT_MAGICK_ERROR();
 812       return NULL;
 813     }
 814
 815     if (MagickSetImageFormat(magick_wand, "bmp") == MagickFalse) {
 816       EXIT_MAGICK_ERROR();
 817       return NULL;
 818     }
 819
 820     if (MagickStripImage(magick_wand) == MagickFalse) {
 821       EXIT_MAGICK_ERROR();
 822       return NULL;
 823     }
 824
 825     if ((magick_wand = s_img_down_sizing(magick_wand, r, spec)) == NULL)
 826       return NULL;
 827
 828     r->content_type = apr_psprintf(r->pool, "image/bmp");
 829
 830     DBG(r,"convert to bmp(unsupported)");
 831   }
 832   /*--------------------------------------------------------------------------*/
 833   /* Add Comment (Copyright and so on.)                                       */
 834   /*--------------------------------------------------------------------------*/
 835   DBG(r,"call s_add_copyright()");
 836
 837   if ((magick_wand = s_add_copyright(magick_wand, r, spec)) == NULL)
 838     return NULL;
 839
 840   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
 841
 842   if (! writebyte) {
 843     DestroyMagickWand(magick_wand);
 844     DBG(r,"convert failure to Jpeg ");
 845     return NULL;
 846   }
 847
 848   DBG(r,"end convert and compression");
 849
 850
 851
 852   dst = apr_palloc(r->pool, writebyte+2);
 853
 854   memcpy(dst, writedata, writebyte);
 855   /*--------------------------------------------------------------------------*/
 856   /* CRC is added for AU for EzGET.                                           */
 857   /*--------------------------------------------------------------------------*/
 858   if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
 859   ||  spec->html_spec_type == CHXJ_SPEC_Hdml) {
 860     crc = s_add_crc(writedata, writebyte);
 861     dst[writebyte + 0] = (crc >> 8) & 0xff;
 862     dst[writebyte + 1] = (crc     ) & 0xff;
 863     writebyte += 2;
 864   }
 865
 866   DestroyMagickWand(magick_wand);
 867
 868   *len = writebyte;
 869   return dst;
 870 }
 871
 872 static MagickWand*
 873 s_fixup_size(MagickWand* magick_wand,
 874                 request_rec* r,
 875                 device_table* spec,
 876                 query_string_param_t *qsp)
 877 {
 878   img_conv_mode_t mode = qsp->mode;
 879   int oldw;
 880   int oldh;
 881   int neww;
 882   int newh;
 883   int c_width;
 884   int c_heigh;
 885
 886   oldw = MagickGetImageWidth(magick_wand);
 887   oldh = MagickGetImageHeight(magick_wand);
 888
 889   DBG1(r,"detect width=[%d]", oldw);
 890   DBG1(r,"detect heigh=[%d]", oldh);
 891
 892   neww = oldw;
 893   newh = oldh;
 894
 895   DBG1(r,"detect spec width=[%d]", spec->width);
 896   DBG1(r,"detect spec heigh=[%d]", spec->heigh);
 897
 898   c_width = spec->width;
 899   c_heigh = spec->heigh;
 900
 901   switch(mode) {
 902   case IMG_CONV_MODE_THUMBNAIL:
 903
 904     DBG(r,"**** detect thumbnail mode ****");
 905
 906     if (neww > c_width) {
 907       newh = (int)((double)newh * (double)((double)c_width / (double)neww));
 908       neww = (int)((double)neww * (double)((double)c_width / (double)neww));
 909     }
 910     if (newh > c_heigh) {
 911       neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 912       newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 913     }
 914
 915     neww = (int)((double)(neww / 3) * 0.8);
 916     newh = (int)((double)(newh / 3) * 0.8);
 917     break;
 918
 919   case IMG_CONV_MODE_WALLPAPER:
 920   case IMG_CONV_MODE_EZGET:
 921
 922     DBG(r,"**** detect wallpaper mode ****");
 923
 924     if (spec->wp_width && spec->wp_heigh) {
 925       c_width = spec->wp_width;
 926       c_heigh = spec->wp_heigh;
 927     }
 928
 929     DBG(r,"calc new width and height");
 930
 931     neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 932     newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 933
 934     DBG2(r,"newh = [%d] neww = [%d]", newh, neww);
 935     break;
 936
 937   default:
 938
 939     DBG(r,"**** detect normal mode ****");
 940
 941     if (qsp->ua_flag != UA_IGN) {
 942       if (neww > c_width) {
 943         newh = (int)((double)newh * (double)((double)c_width / (double)neww));
 944         neww = (int)((double)neww * (double)((double)c_width / (double)neww));
 945       }
 946
 947       if (newh > c_heigh) {
 948         neww = (int)((double)neww * (double)((double)c_heigh / (double)newh));
 949         newh = (int)((double)newh * (double)((double)c_heigh / (double)newh));
 950       }
 951     }
 952     break;
 953   }
 954
 955   DBG2(r,"convert width=[%d --> %d]", oldw, neww);
 956   DBG2(r,"convert heigh=[%d --> %d]", oldh, newh);
 957
 958   MagickResetIterator(magick_wand);
 959
 960   while (MagickNextImage(magick_wand) != MagickFalse) {
 961     switch (mode) {
 962     case IMG_CONV_MODE_WALLPAPER:
 963     case IMG_CONV_MODE_EZGET:
 964
 965       if (MagickResizeImage(magick_wand,neww,newh,LanczosFilter,1.0) == MagickFalse) {
 966         EXIT_MAGICK_ERROR();
 967         return NULL;
 968       }
 969
 970       if (MagickCropImage(magick_wand,
 971                       (unsigned long)c_width,
 972                       (unsigned long)c_heigh,
 973                       (long)((neww - c_width) / 2),
 974                       (long)((newh - c_heigh) / 2)) == MagickFalse) {
 975         EXIT_MAGICK_ERROR();
 976         return NULL;
 977       }
 978       break;
 979
 980     case IMG_CONV_MODE_NORMAL:
 981       if (qsp->width) {
 982         DBG2(r,"convert width=[%d --> %d]", neww, qsp->width);
 983         neww = qsp->width;
 984       }
 985       if (qsp->height) {
 986         DBG2(r,"convert heigh=[%d --> %d]", newh, qsp->height);
 987         newh = qsp->height;
 988       }
 989
 990     default:
 991       if (MagickResizeImage(magick_wand,neww,newh,LanczosFilter,1.0) == MagickFalse) {
 992         EXIT_MAGICK_ERROR();
 993         return NULL;
 994       }
 995       break;
 996     }
 997
 998     if (MagickSetImageUnits(magick_wand, PixelsPerInchResolution) == MagickFalse) {
 999       EXIT_MAGICK_ERROR();
1000       return NULL;
1001     }
1002
1003     if (MagickSetImageResolution(magick_wand,
1004                                  (double)spec->dpi_width,
1005                                  (double)spec->dpi_heigh) == MagickFalse) {
1006       EXIT_MAGICK_ERROR();
1007       return NULL;
1008     }
1009
1010     if (MagickSetImageDispose(magick_wand, BackgroundDispose) == MagickFalse) {
1011       EXIT_MAGICK_ERROR();
1012       return NULL;
1013     }
1014   }
1015
1016   return magick_wand;
1017 }
1018
1019 static MagickWand*
1020 s_fixup_color(MagickWand* magick_wand, request_rec* r, device_table* spec, img_conv_mode_t mode)
1021 {
1022   DBG(r,"start chxj_fixup_clor()");
1023
1024   if (spec->color >= 256) {
1025
1026     DBG1(r,"call MagickQuantizeImage() spec->color=[%d]",spec->color);
1027
1028     if (MagickQuantizeImage(magick_wand,
1029                            spec->color,
1030                            RGBColorspace,
1031                            0,
1032                            1,
1033                            0) == MagickFalse) {
1034       EXIT_MAGICK_ERROR();
1035       return NULL;
1036     }
1037
1038     DBG1(r,"call end MagickQuantizeImage() spec->color=[%d]",spec->color);
1039
1040   }
1041   else {
1042     DBG1(r,"call MagickQuantizeImage() spec->color=[%d]",spec->color);
1043
1044     if (MagickQuantizeImage(magick_wand,
1045                            spec->color,
1046                            GRAYColorspace,
1047                            0,
1048                            1,
1049                            0) == MagickFalse) {
1050       EXIT_MAGICK_ERROR();
1051       return NULL;
1052     }
1053
1054     DBG1(r,"call end MagickQuantizeImage() spec->color=[%d]",spec->color);
1055   }
1056
1057
1058   DBG(r,"end chxj_fixup_clor()");
1059
1060   return magick_wand;
1061 }
1062
1063
1064
1065 static MagickWand*
1066 s_fixup_depth(MagickWand* magick_wand, request_rec* r, device_table* spec)
1067 {
1068   if (spec->color == 15680000) {
1069     if (MagickSetImageDepth(magick_wand, 24) == MagickFalse) {
1070       EXIT_MAGICK_ERROR();
1071       return NULL;
1072     }
1073   }
1074   else
1075   if (spec->color == 262144) {
1076     if (MagickSetImageDepth(magick_wand, 18) == MagickFalse) {
1077       EXIT_MAGICK_ERROR();
1078       return NULL;
1079     }
1080   }
1081   else
1082   if (spec->color == 65536) {
1083     if (MagickSetImageDepth(magick_wand, 16) == MagickFalse) {
1084       EXIT_MAGICK_ERROR();
1085       return NULL;
1086     }
1087   }
1088   else
1089   if (spec->color == 4096) {
1090     if (MagickSetImageDepth(magick_wand, 12) == MagickFalse) {
1091       EXIT_MAGICK_ERROR();
1092       return NULL;
1093     }
1094   }
1095   else
1096   if (spec->color == 256) {
1097     if (MagickSetImageDepth(magick_wand, 8) == MagickFalse) {
1098       EXIT_MAGICK_ERROR();
1099       return NULL;
1100     }
1101   }
1102   else
1103   if (spec->color == 4) {
1104     if (MagickSetImageDepth(magick_wand, 2) == MagickFalse) {
1105       EXIT_MAGICK_ERROR();
1106       return NULL;
1107     }
1108   }
1109   else
1110   if (spec->color == 2) {
1111     if (MagickSetImageDepth(magick_wand, 1) == MagickFalse) {
1112       EXIT_MAGICK_ERROR();
1113       return NULL;
1114     }
1115   }
1116
1117   return magick_wand;
1118 }
1119
1120
1121 static MagickWand*
1122 s_add_copyright(MagickWand* magick_wand, request_rec* r, device_table* spec)
1123 {
1124   mod_chxj_config* conf = ap_get_module_config(r->per_dir_config, &chxj_module);
1125
1126   if (conf->image_copyright) {
1127
1128     DBG1(r, "Add COPYRIGHT [%s]", conf->image_copyright);
1129
1130     if (spec->html_spec_type == CHXJ_SPEC_Jhtml) {
1131       apr_table_setn(r->headers_out, "x-jphone-copyright", "no-transfer");
1132       if (MagickCommentImage(magick_wand,
1133                              apr_psprintf(r->pool,
1134                                           "Copyright(C) %s",
1135                                           conf->image_copyright)) == MagickFalse)
1136         goto on_error;
1137     }
1138     else
1139     if (spec->html_spec_type == CHXJ_SPEC_XHtml_Mobile_1_0
1140     ||  spec->html_spec_type == CHXJ_SPEC_Hdml) {
1141       if (MagickCommentImage(magick_wand,
1142                              apr_psprintf(r->pool,
1143                                          "kddi_copyright=on,%s",
1144                                           conf->image_copyright)) == MagickFalse)
1145         goto on_error;
1146     }
1147     else {
1148       if (MagickCommentImage(magick_wand,
1149                             apr_psprintf(r->pool,
1150                                          "copy=\"NO\",%s",
1151                                          conf->image_copyright)) == MagickFalse)
1152         goto on_error;
1153     }
1154   }
1155   else {
1156     if (MagickCommentImage(magick_wand, "mod_chxj") == MagickFalse)
1157       goto on_error;
1158   }
1159   return magick_wand;
1160
1161 on_error:
1162   EXIT_MAGICK_ERROR();
1163   return NULL;
1164 }
1165
1166 static MagickWand*
1167 s_img_down_sizing(MagickWand* magick_wand, request_rec* r, device_table* spec)
1168 {
1169   MagickBooleanType  status;
1170   unsigned long quality = 70;
1171   apr_size_t    writebyte = 0;
1172   char*         writedata;
1173   apr_size_t    prev_size = 0;
1174   int           revers_flag = 0;
1175
1176   writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1177   prev_size = writebyte;
1178
1179   do {
1180     if (MagickSetImageCompressionQuality(magick_wand, quality) == MagickFalse) {
1181       EXIT_MAGICK_ERROR();
1182       return NULL;
1183     }
1184
1185     writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1186     if (writebyte >= prev_size || revers_flag) {
1187       DBG2(r, "quality=[%ld] size=[%d]", (long)quality, writebyte);
1188       revers_flag = 1;
1189       quality += 10;
1190       if (quality > 100) {
1191         if (MagickSetImageCompression(magick_wand,NoCompression) == MagickFalse) {
1192           EXIT_MAGICK_ERROR();
1193           return NULL;
1194         }
1195         break;
1196       }
1197       prev_size = writebyte;
1198       continue;
1199     }
1200
1201     DBG2(r, "quality=[%ld] size=[%d]", (long)quality, writebyte);
1202
1203     if (spec->cache == 0)
1204       break;
1205
1206     if (writebyte <= spec->cache)
1207       break;
1208
1209     quality -= 10;
1210
1211     if (quality == 0 || quality > 100)
1212       break;
1213
1214   }
1215   while (1);
1216
1217
1218   if (spec->cache > 0
1219   &&  writebyte   > spec->cache) {
1220     unsigned long now_color = spec->color;
1221     unsigned long depth     = 0;
1222     do {
1223       switch(now_color) {
1224       case 2:      depth = 1; break;
1225       case 4:      now_color = 2;        depth = 1;  break;
1226       case 8:      now_color = 4;        depth = 2;  break;
1227       case 16:     now_color = 8;        depth = 3;  break;
1228       case 256:    now_color = 16;       depth = 4;  break;
1229       case 4096:   now_color = 256;      depth = 8;  break;
1230       case 65536:  now_color = 4096;     depth = 12; break;
1231       case 262144: now_color = 65536;    depth = 16; break;
1232       case 15680000: now_color = 262144; depth = 18; break;
1233       default:
1234         now_color = 2;
1235         break;
1236       }
1237
1238       if (now_color <= 2) break;
1239
1240       if (now_color >= 8) {
1241         status = MagickQuantizeImage(magick_wand,
1242                              now_color,
1243                              RGBColorspace,
1244                              0,
1245                              1,
1246                              0);
1247       }
1248       else {
1249         status = MagickQuantizeImage(magick_wand,
1250                              now_color,
1251                              GRAYColorspace,
1252                              0,
1253                              1,
1254                              0);
1255         MagickSetImageType(magick_wand, GrayscaleType);
1256       }
1257       if (status == MagickFalse) {
1258         EXIT_MAGICK_ERROR();
1259         return NULL;
1260       }
1261
1262       if (MagickSetImageDepth(magick_wand, depth) == MagickFalse) {
1263         EXIT_MAGICK_ERROR();
1264         return NULL;
1265       }
1266
1267       writedata = (char*)MagickGetImageBlob(magick_wand, &writebyte);
1268
1269       DBG2(r,"now_color=[%ld] size=[%d]", (long)now_color, writebyte);
1270
1271       /* Once per request */
1272       break;
1273     }
1274     while(now_color > 2);
1275   }
1276
1277   return magick_wand;
1278 }
1279
1280 static apr_status_t
1281 s_send_cache_file(device_table* spec, query_string_param_t* query_string, request_rec* r, const char* tmpfile)
1282 {
1283   apr_status_t rv;
1284   apr_finfo_t  st;
1285   apr_file_t*  fout;
1286   apr_size_t   sendbyte;
1287   char*        contentLength;
1288
1289   rv = apr_stat(&st, tmpfile, APR_FINFO_MIN, r->pool);
1290   if (rv != APR_SUCCESS)
1291     return HTTP_NOT_FOUND;
1292
1293   DBG1(r, "mode:[%d]",    query_string->mode);
1294   DBG1(r, "name:[%s]",    query_string->name);
1295   DBG1(r, "offset:[%ld]", query_string->offset);
1296   DBG1(r, "count:[%ld]",  query_string->count);
1297
1298   if (spec->available_jpeg) {
1299     r->content_type = apr_psprintf(r->pool, "image/jpeg");
1300   }
1301   else
1302   if (spec->available_png) {
1303     r->content_type = apr_psprintf(r->pool, "image/png");
1304   }
1305   else
1306   if (spec->available_gif) {
1307     r->content_type = apr_psprintf(r->pool, "image/gif");
1308   }
1309   else
1310   if (spec->available_bmp2 || spec->available_bmp4) {
1311     r->content_type = apr_psprintf(r->pool, "image/bmp");
1312   }
1313
1314   if (query_string->mode != IMG_CONV_MODE_EZGET && query_string->name == NULL) {
1315     contentLength = apr_psprintf(r->pool, "%d", (int)st.size);
1316     apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1317
1318     DBG1(r,"Content-Length:[%d]", (int)st.size);
1319
1320     rv = apr_file_open(&fout, tmpfile,
1321       APR_READ | APR_BINARY, APR_OS_DEFAULT, r->pool);
1322     if (rv != APR_SUCCESS) {
1323       DBG1(r, "tmpfile open failed[%s]", tmpfile);
1324       return HTTP_NOT_FOUND;
1325     }
1326
1327     ap_send_fd(fout, r, 0, st.size, &sendbyte);
1328     apr_file_close(fout);
1329     ap_rflush(r);
1330     DBG1(r, "send file data[%d]byte", sendbyte);
1331   }
1332   else
1333   if (query_string->mode == IMG_CONV_MODE_EZGET) {
1334     char* name = apr_pstrdup(r->pool, basename(r->filename));
1335     name[strlen(name)-4] = 0;
1336     if (strcasecmp(r->content_type, "image/jpeg") == 0) {
1337
1338       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1339       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".jpg", (long)st.size, "devjaww", name);
1340     }
1341     else
1342     if (strcasecmp(r->content_type, "image/bmp") == 0) {
1343       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1344       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".bmp", (long)st.size, "devabm", name);
1345     }
1346     else
1347     if (strcasecmp(r->content_type, "image/png") == 0) {
1348       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1349       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".png", (long)st.size, "dev8aww", name);
1350     }
1351     else
1352     if (strcasecmp(r->content_type, "image/gif") == 0) {
1353       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1354       ap_rprintf(r, HDML_FIRST_PAGE, r->uri, name, ".gif", (long)st.size, "devgi0z", name);
1355     }
1356   }
1357   else
1358   if (query_string->mode == IMG_CONV_MODE_WALLPAPER && query_string->name != NULL) {
1359     if (query_string->count == -1 && query_string->offset == -1) {
1360       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1361       ap_rprintf(r, HDML_SUCCESS_PAGE);
1362       ap_rflush(r);
1363     }
1364     else
1365     if (query_string->count == -2 && query_string->offset == -1) {
1366       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1367       ap_rprintf(r, HDML_FAIL_PAGE);
1368       ap_rflush(r);
1369     }
1370     else {
1371       ap_set_content_type(r, "application/x-up-download");
1372       contentLength = apr_psprintf(r->pool, "%ld", query_string->count);
1373       apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1374
1375       DBG1(r, "Content-Length:[%d]", (int)st.size);
1376
1377       rv = apr_file_open(&fout, tmpfile,
1378         APR_READ | APR_BINARY, APR_OS_DEFAULT, r->pool);
1379
1380       if (rv != APR_SUCCESS) {
1381         DBG1(r,"tmpfile open failed[%s]", tmpfile);
1382         return HTTP_NOT_FOUND;
1383       }
1384
1385       ap_send_fd(fout, r, query_string->offset, query_string->count, &sendbyte);
1386       apr_file_close(fout);
1387       ap_rflush(r);
1388       DBG1(r, "send file data[%d]byte", sendbyte);
1389     }
1390   }
1391
1392   return OK;
1393 }
1394
1395 static apr_status_t
1396 s_header_only_cache_file(device_table* spec, query_string_param_t* query_string, request_rec* r, const char* tmpfile)
1397 {
1398   apr_status_t rv;
1399   apr_finfo_t  st;
1400   char*        contentLength;
1401
1402   rv = apr_stat(&st, tmpfile, APR_FINFO_MIN, r->pool);
1403   if (rv != APR_SUCCESS)
1404     return HTTP_NOT_FOUND;
1405
1406   DBG1(r, "mode:[%d]",    query_string->mode);
1407   DBG1(r, "name:[%s]",    query_string->name);
1408   DBG1(r, "offset:[%ld]", query_string->offset);
1409   DBG1(r, "count:[%ld]",  query_string->count);
1410
1411   if (spec->available_jpeg) {
1412     r->content_type = apr_psprintf(r->pool, "image/jpeg");
1413   }
1414   else
1415   if (spec->available_png) {
1416     r->content_type = apr_psprintf(r->pool, "image/png");
1417   }
1418   else
1419   if (spec->available_gif) {
1420     r->content_type = apr_psprintf(r->pool, "image/gif");
1421   }
1422   else
1423   if (spec->available_bmp2 || spec->available_bmp4) {
1424     r->content_type = apr_psprintf(r->pool, "image/bmp");
1425   }
1426
1427   if (query_string->mode != IMG_CONV_MODE_EZGET && query_string->name == NULL) {
1428     contentLength = apr_psprintf(r->pool, "%d", (int)st.size);
1429     apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1430
1431     DBG1(r,"Content-Length:[%d]", (int)st.size);
1432   }
1433   else
1434   if (query_string->mode == IMG_CONV_MODE_EZGET) {
1435     char* name = apr_pstrdup(r->pool, basename(r->filename));
1436     name[strlen(name)-4] = 0;
1437     if (strcasecmp(r->content_type, "image/jpeg") == 0) {
1438
1439       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1440     }
1441     else
1442     if (strcasecmp(r->content_type, "image/bmp") == 0) {
1443       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1444     }
1445     else
1446     if (strcasecmp(r->content_type, "image/png") == 0) {
1447       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1448     }
1449     else
1450     if (strcasecmp(r->content_type, "image/gif") == 0) {
1451       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1452     }
1453   }
1454   else
1455   if (query_string->mode == IMG_CONV_MODE_WALLPAPER && query_string->name != NULL) {
1456     if (query_string->count == -1 && query_string->offset == -1) {
1457       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1458     }
1459     else
1460     if (query_string->count == -2 && query_string->offset == -1) {
1461       ap_set_content_type(r, "text/x-hdml; charset=Shift_JIS");
1462     }
1463     else {
1464       ap_set_content_type(r, "application/x-up-download");
1465       contentLength = apr_psprintf(r->pool, "%ld", query_string->count);
1466       apr_table_setn(r->headers_out, "Content-Length", (const char*)contentLength);
1467
1468       DBG1(r, "Content-Length:[%d]", (int)st.size);
1469     }
1470   }
1471
1472   return OK;
1473 }
1474
1475
1476
1477 static char*
1478 s_create_workfile(
1479                 request_rec*          r,
1480                 mod_chxj_config*      conf,
1481                 const char*           user_agent,
1482                 query_string_param_t *qsp)
1483 {
1484   int ii;
1485   int jj;
1486   int len;
1487   char* w = apr_palloc(r->pool, 256);
1488   char* fname;
1489
1490   memset(w, 0, 256);
1491   switch (qsp->mode) {
1492   case IMG_CONV_MODE_THUMBNAIL:
1493     fname = apr_psprintf(r->pool, "%s.%s.thumbnail", r->filename, user_agent);
1494     DBG1(r, "mode=thumbnail [%s]", fname);
1495     break;
1496   case IMG_CONV_MODE_WALLPAPER:
1497   case IMG_CONV_MODE_EZGET:
1498     fname = apr_psprintf(r->pool, "%s.%s.wallpaper", r->filename, user_agent);
1499     DBG1(r, "mode=WallPaper [%s]", fname);
1500     break;
1501   case IMG_CONV_MODE_NORMAL:
1502   default:
1503
1504     fname = apr_psprintf(r->pool, "%s.%s", r->filename, user_agent);
1505
1506     if (qsp->width)
1507       fname = apr_psprintf(r->pool, "%s.w%d", fname, qsp->width);
1508
1509     if (qsp->height)
1510       fname = apr_psprintf(r->pool, "%s.h%d", fname, qsp->height);
1511
1512     DBG1(r,"mode=normal [%s]", fname);
1513     break;
1514   }
1515   if (qsp->ua_flag == UA_IGN) {
1516     fname = apr_psprintf(r->pool, "%s.IGN", fname);
1517   }
1518
1519   len = strlen(fname);
1520   jj=0;
1521   for  (ii=0; ii<len; ii++) {
1522     if (fname[ii] == '/'
1523     ||  fname[ii] == ' '
1524     ||  fname[ii] == '-'
1525     ||  fname[ii] == '('
1526     ||  fname[ii] == ')') {
1527       w[jj++] = '_';
1528     }
1529     else {
1530       w[jj++] = fname[ii];
1531     }
1532   }
1533
1534   return apr_psprintf(r->pool, "%s/%s", conf->image_cache_dir,w);
1535 }
1536
1537 static unsigned short
1538 s_add_crc(const char* writedata, apr_size_t writebyte)
1539 {
1540   unsigned short crc = 0xffff;
1541   apr_size_t     ii;
1542   unsigned char  ch;
1543
1544   for(ii=0;ii<writebyte;ii++) {
1545     ch  = writedata[ii];
1546     crc = AU_CRC_TBL[(crc>>8^ch)&0xff]^(crc<<8);
1547   }
1548   return crc;
1549 }
1550
1551 int
1552 chxj_trans_name(request_rec *r)
1553 {
1554   const char* ccp;
1555   char* docroot;
1556   int len;
1557   apr_finfo_t st;
1558   apr_status_t rv;
1559   mod_chxj_config* conf;
1560   int ii;
1561   char*      ext[] = {
1562           "jpg",
1563           "jpeg",
1564           "png",
1565           "bmp",
1566           "gif",
1567           "qrc",    /* QRCode½ÐÎÏÍÑ¥Õ¥¡¥¤¥ë¤Î³ÈÄ¥»Ò */
1568           "",
1569   };
1570   char*    fname;
1571   char*    idx;
1572   char*    filename_sv;
1573   int      do_ext_check = TRUE;
1574   int      next_ok      = FALSE;
1575
1576   DBG(r, "start chxj_trans_name()");
1577
1578   conf = ap_get_module_config(r->per_dir_config, &chxj_module);
1579
1580   if (conf == NULL) {
1581     DBG1(r, "end chxj_trans_name() conf is null[%s]", r->uri);
1582     return DECLINED;
1583   }
1584
1585   if (conf->image != CHXJ_IMG_ON) {
1586     DBG(r, "end chxj_trans_name() conf not found");
1587     return DECLINED;
1588   }
1589
1590
1591   DBG1(r,"Match URI[%s]", r->uri);
1592
1593
1594   if (r->filename == NULL)
1595     r->filename = apr_pstrdup(r->pool, r->uri);
1596
1597   filename_sv = NULL;
1598   if ((idx = strchr(r->filename, ':')) != NULL)
1599     filename_sv = idx+1;
1600   else
1601     filename_sv = r->filename;
1602
1603   DBG1(r,"r->filename[%s]", filename_sv);
1604
1605   ccp = ap_document_root(r);
1606   if (ccp == NULL)
1607     return HTTP_INTERNAL_SERVER_ERROR;
1608
1609   docroot = apr_pstrdup(r->pool, ccp);
1610   len = strlen(docroot);
1611
1612   if (docroot[len-1] == '/')
1613     docroot[len-1] = '\0';
1614
1615
1616   if (r->server->path
1617   &&  *filename_sv == *r->server->path
1618   &&  strncmp(filename_sv, r->server->path, r->server->pathlen) == 0)
1619     filename_sv = apr_pstrcat(r->pool, docroot, (filename_sv + r->server->pathlen), NULL);
1620   else
1621     filename_sv = apr_pstrcat(r->pool, docroot, filename_sv, NULL);
1622
1623   DBG1(r,"URI[%s]", filename_sv);
1624
1625   do_ext_check = TRUE;
1626   for (ii=0; ii<7-1; ii++) {
1627     char* pos = strrchr(filename_sv, '.');
1628     if (pos && pos++) {
1629       if (strcasecmp(pos, ext[ii]) == 0) {
1630         do_ext_check = FALSE;
1631         fname = apr_psprintf(r->pool, "%s", filename_sv);
1632         break;
1633       }
1634     }
1635   }
1636
1637   if (do_ext_check) {
1638     for (ii=0; ii<7; ii++) {
1639       if (strlen(ext[ii]) == 0) {
1640         fname = apr_psprintf(r->pool, "%s", filename_sv);
1641       }
1642       else
1643         fname = apr_psprintf(r->pool, "%s.%s", filename_sv, ext[ii]);
1644
1645       DBG1(r,"search [%s]", fname);
1646
1647       rv = apr_stat(&st, fname, APR_FINFO_MIN, r->pool);
1648       if (rv == APR_SUCCESS) {
1649         if (st.filetype != APR_DIR)
1650           break;
1651       }
1652
1653       fname = NULL;
1654     }
1655   }
1656   if (fname == NULL) {
1657     DBG1(r,"NotFound [%s]", r->filename);
1658     return DECLINED;
1659   }
1660   for (ii=0; ii<7-1; ii++) {
1661     char* pos = strrchr(fname, '.');
1662     if (pos && pos++) {
1663       if (strcasecmp(pos, ext[ii]) == 0) {
1664         next_ok = TRUE;
1665         break;
1666       }
1667     }
1668   }
1669
1670   if (! next_ok)  {
1671     DBG1(r,"NotFound [%s]", r->filename);
1672     return DECLINED;
1673   }
1674
1675   if (r->handler == NULL || strcasecmp(r->handler, "chxj-qrcode") != 0) {
1676     DBG1(r,"Found [%s]", fname);
1677
1678     r->filename = apr_psprintf(r->pool, "%s", fname);
1679
1680     if (strcasecmp("qrc", ext[ii]) == 0)
1681       r->handler = apr_psprintf(r->pool, "chxj-qrcode");
1682     else
1683       r->handler = apr_psprintf(r->pool, "chxj-picture");
1684   }
1685   DBG(r, "end chxj_trans_name()");
1686   return OK;
1687 }
1688
1689
1690
1691 /**
1692  * It converts it from QUERYSTRING.
1693  *
1694  * @param r   [i]
1695  */
1696 static query_string_param_t*
1697 s_get_query_string_param(request_rec *r)
1698 {
1699   char* pair;
1700   char* name;
1701   char* value;
1702   char* pstate;
1703   char* vstate;
1704   char* s;
1705   query_string_param_t* param;
1706
1707   s = apr_pstrdup(r->pool, r->parsed_uri.query);
1708   param = apr_palloc(r->pool, sizeof(query_string_param_t));
1709   param->mode       = IMG_CONV_MODE_NORMAL;
1710   param->user_agent = NULL;
1711   param->ua_flag    = UA_USE;
1712   param->name       = NULL;
1713   param->offset     = 0;
1714   param->count      = 0;
1715   param->width      = 0;
1716   param->height     = 0;
1717
1718   if (s == NULL) return param;
1719
1720   for (;;) {
1721     if ((pair = apr_strtok(s, "&", &pstate)) == NULL) break;
1722     s = NULL;
1723
1724     name  = apr_strtok(pair, "=", &vstate);
1725     value = apr_strtok(NULL, "=", &vstate);
1726
1727     switch (*name) {
1728     case 'm':
1729     case 'M':
1730       if (value && (strcasecmp(name, "mode") == 0 || strcasecmp(name, "m") == 0)) {
1731
1732         switch (*value) {
1733         case 't':
1734         case 'T':
1735           if (strcasecmp(value, "thumbnail") == 0 || strcasecmp(value, "tb") == 0)
1736             param->mode = IMG_CONV_MODE_THUMBNAIL;
1737           break;
1738
1739         case 'w':
1740         case 'W':
1741           if (strcasecmp(value, "WP") == 0 || strcasecmp(value, "WallPaper") == 0)
1742             param->mode = IMG_CONV_MODE_WALLPAPER;
1743           break;
1744
1745         case 'e':
1746         case 'E':
1747           if (strcasecmp(value, "EZGET") == 0)
1748             param->mode = IMG_CONV_MODE_EZGET;
1749           break;
1750         default:
1751           break;
1752         }
1753       }
1754       break;
1755
1756     case 'u':
1757     case 'U':
1758       if (value && (strcasecmp(name, "ua") == 0 || strcasecmp(name, "user-agent") == 0)) {
1759         ap_unescape_url(value);
1760
1761         if ((*value == 'i' || *value == 'I') && strcasecmp(value, "IGN") == 0)
1762           param->ua_flag = UA_IGN;
1763
1764         param->user_agent = apr_pstrdup(r->pool, value);
1765       }
1766       break;
1767
1768     case 'n':
1769     case 'N':
1770       if (value && strcasecmp(name, "name") == 0)
1771         param->name = apr_pstrdup(r->pool, value);
1772       break;
1773
1774     case 'o':
1775     case 'O':
1776       if (value && strcasecmp(name, "offset") == 0 && (! chxj_chk_numeric(value)))
1777         param->offset = chxj_atoi(value);
1778
1779       break;
1780
1781     case 'c':
1782     case 'C':
1783       if (value && strcasecmp(name, "count") == 0 && (! chxj_chk_numeric(value)))
1784         param->count = chxj_atoi(value);
1785       break;
1786
1787     case 'w':
1788     case 'W':
1789       if (value && strcasecmp(name, "w") == 0 && (! chxj_chk_numeric(value)))
1790         param->width = chxj_atoi(value);
1791       break;
1792
1793     case 'h':
1794     case 'H':
1795       if (value && strcasecmp(name, "h") == 0 && (! chxj_chk_numeric(value)))
1796         param->height = chxj_atoi(value);
1797       break;
1798
1799     default:
1800       break;
1801     }
1802   }
1803
1804   if (param->mode == IMG_CONV_MODE_NORMAL && param->name)
1805     param->mode = IMG_CONV_MODE_WALLPAPER;
1806
1807   return param;
1808 }
1809 /*
1810  * vim:ts=2 et
1811  */