src/chxj_img_conv_format.c

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