| /* |
| * $Id$ |
| * |
| * Copyright (c) 2002-2014, Universite catholique de Louvain (UCL), Belgium |
| * Copyright (c) 2002-2014, Professor Benoit Macq |
| * Copyright (c) 2010-2011, Kaori Hagihara |
| * Copyright (c) 2011, Lucian Corlaciu, GSoC |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| #ifdef _WIN32 |
| #include <windows.h> |
| #define strcasecmp _stricmp |
| #define strncasecmp _strnicmp |
| #else |
| #include <strings.h> |
| #endif |
| |
| #include <stdio.h> |
| #include <assert.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include "query_parser.h" |
| #include "opj_stdint.h" |
| |
| #ifdef SERVER |
| #include "fcgi_stdio.h" |
| #define logstream FCGI_stdout |
| #else |
| #define FCGI_stdout stdout |
| #define FCGI_stderr stderr |
| #define logstream stderr |
| #endif /*SERVER*/ |
| |
| |
| /** |
| * Get initialized query parameters |
| * |
| * @return initial query parameters |
| */ |
| query_param_t * get_initquery(void); |
| |
| /* |
| * get a pair of field name and value from the string starting fieldname=fieldval&... format |
| * |
| * @param[in] stringptr pointer to the beginning of the parsing string |
| * @param[out] fieldname string to copy the field name, if not found, NULL |
| * @param[out] fieldval string to copy the field value, if not found, NULL |
| * @return pointer to the next field string, if there is none, NULL |
| */ |
| char * get_fieldparam( const char *stringptr, char *fieldname, char *fieldval); |
| |
| void parse_cclose( char *src, query_param_t *query_param); |
| void parse_metareq( char *field, query_param_t *query_param); |
| |
| /* parse the requested components (parses forms like:a; a,b; a-b; a-b,c; a,b-c)*/ |
| void parse_comps( char *field, query_param_t *query_param); |
| |
| |
| /** maximum length of field name*/ |
| #define MAX_LENOFFIELDNAME 10 |
| |
| /** maximum length of field value*/ |
| #define MAX_LENOFFIELDVAL 128 |
| |
| query_param_t * parse_query( const char *query_string) |
| { |
| query_param_t *query_param; |
| const char *pquery; |
| char fieldname[MAX_LENOFFIELDNAME], fieldval[MAX_LENOFFIELDVAL]; |
| |
| query_param = get_initquery(); |
| |
| pquery = query_string; |
| |
| while( pquery!=NULL) { |
| |
| pquery = get_fieldparam( pquery, fieldname, fieldval); |
| |
| if( fieldname[0] != '\0') { |
| if( strcasecmp( fieldname, "target") == 0) |
| query_param->target = strdup( fieldval); |
| |
| else if( strcasecmp( fieldname, "tid") == 0) |
| query_param->tid = strdup( fieldval); |
| |
| else if( strcasecmp( fieldname, "fsiz") == 0) |
| sscanf( fieldval, "%d,%d", &query_param->fx, &query_param->fy); |
| |
| else if( strcasecmp( fieldname, "roff") == 0) |
| sscanf( fieldval, "%d,%d", &query_param->rx, &query_param->ry); |
| |
| else if( strcasecmp( fieldname, "rsiz") == 0) |
| sscanf( fieldval, "%d,%d", &query_param->rw, &query_param->rh); |
| |
| else if( strcasecmp( fieldname, "layers") == 0) |
| sscanf( fieldval, "%d", &query_param->layers); |
| |
| else if( strcasecmp( fieldname, "cid") == 0) |
| query_param->cid = strdup( fieldval); |
| |
| else if( strcasecmp( fieldname, "cnew") == 0) { |
| if( strncasecmp( fieldval, "http-tcp", 8) == 0) |
| query_param->cnew = tcp; |
| else if( strncasecmp( fieldval, "http", 4) == 0) |
| query_param->cnew = http; |
| } |
| |
| else if( strcasecmp( fieldname, "cclose") == 0) |
| parse_cclose( fieldval, query_param); |
| |
| else if( strcasecmp( fieldname, "metareq") == 0) |
| parse_metareq( fieldval, query_param); |
| |
| else if( strcasecmp( fieldname, "comps") == 0) |
| parse_comps( fieldval, query_param); |
| |
| else if( strcasecmp( fieldname, "type") == 0) { |
| if( strncasecmp( fieldval, "jpp-stream", 10) == 0) |
| query_param->return_type = JPPstream; |
| else if( strncasecmp( fieldval, "jpt-stream", 10) == 0) |
| query_param->return_type = JPTstream; |
| } |
| |
| else if( strcasecmp( fieldname, "len") == 0) { |
| sscanf( fieldval, "%d", &query_param->len); |
| if( query_param->len == 2000) /* for kakadu client*/ |
| strncpy( query_param->box_type[0], "ftyp", 4); |
| } |
| } |
| } |
| return query_param; |
| } |
| |
| query_param_t * get_initquery(void) |
| { |
| query_param_t *query; |
| int i; |
| |
| query = (query_param_t *)opj_malloc( sizeof(query_param_t)); |
| |
| query->target = NULL; |
| query->tid = NULL; |
| query->fx = -1; |
| query->fy = -1; |
| query->rx = -1; |
| query->ry = -1; |
| query->rw = -1; |
| query->rh = -1; |
| query->layers = -1; |
| query->lastcomp = -1; |
| query->comps = NULL; |
| query->cid = NULL; |
| query->cnew = non; |
| query->cclose = NULL; |
| query->numOfcclose = 0; |
| memset( query->box_type, 0, MAX_NUMOFBOX*4); |
| memset( query->limit, 0, MAX_NUMOFBOX*sizeof(int)); |
| for( i=0; i<MAX_NUMOFBOX; i++) { |
| query->w[i] = OPJ_FALSE; |
| query->s[i] = OPJ_FALSE; |
| query->g[i] = OPJ_FALSE; |
| query->a[i] = OPJ_FALSE; |
| query->priority[i] = OPJ_FALSE; |
| } |
| query->root_bin = 0; |
| query->max_depth = -1; |
| query->metadata_only = OPJ_FALSE; |
| query->return_type = UNKNOWN; |
| query->len = -1; |
| |
| return query; |
| } |
| |
| |
| char * get_fieldparam( const char *stringptr, char *fieldname, char *fieldval) |
| { |
| char *eqp, *andp, *nexfieldptr; |
| |
| if((eqp = strchr( stringptr, '='))==NULL) { |
| fprintf( stderr, "= not found\n"); |
| strcpy( fieldname, ""); |
| strcpy( fieldval, ""); |
| return NULL; |
| } |
| if((andp = strchr( stringptr, '&'))==NULL) { |
| andp = strchr( stringptr, '\0'); |
| nexfieldptr = NULL; |
| } else |
| nexfieldptr = andp+1; |
| |
| assert( (size_t)(eqp-stringptr)); |
| strncpy( fieldname, stringptr, (size_t)(eqp-stringptr)); |
| fieldname[eqp-stringptr]='\0'; |
| assert( andp-eqp-1 >= 0); |
| strncpy( fieldval, eqp+1, (size_t)(andp-eqp-1)); |
| fieldval[andp-eqp-1]='\0'; |
| |
| return nexfieldptr; |
| } |
| |
| void print_queryparam( query_param_t query_param) |
| { |
| int i; |
| char *cclose; |
| |
| fprintf( logstream, "query parameters:\n"); |
| |
| if( query_param.target) |
| fprintf( logstream, "\t target: %s\n", query_param.target); |
| |
| if( query_param.tid) |
| fprintf( logstream, "\t tid: %s\n", query_param.tid); |
| |
| fprintf( logstream, "\t fx,fy: %d, %d\n", query_param.fx, query_param.fy); |
| fprintf( logstream, "\t rx,ry: %d, %d \t rw,rh: %d, %d\n", query_param.rx, query_param.ry, query_param.rw, query_param.rh); |
| fprintf( logstream, "\t layers: %d\n", query_param.layers); |
| fprintf( logstream, "\t components: "); |
| |
| if( query_param.lastcomp == -1) |
| fprintf( logstream, "ALL\n"); |
| else { |
| for( i=0; i<=query_param.lastcomp; i++) |
| if( query_param.comps[i]) |
| fprintf( logstream, "%d ", i); |
| fprintf( logstream, "\n"); |
| } |
| fprintf( logstream, "\t cnew: %d\n", query_param.cnew); |
| |
| if( query_param.cid) |
| fprintf( logstream, "\t cid: %s\n", query_param.cid); |
| |
| if( query_param.cclose) { |
| fprintf( logstream, "\t cclose: "); |
| |
| for( i=0, cclose=query_param.cclose; i<query_param.numOfcclose; i++) { |
| fprintf( logstream, "%s ", cclose); |
| cclose += (strlen(cclose)+1); |
| } |
| fprintf(logstream, "\n"); |
| } |
| |
| fprintf( logstream, "\t req-box-prop\n"); |
| for( i=0; query_param.box_type[i][0]!=0 && i<MAX_NUMOFBOX; i++) { |
| fprintf( logstream, "\t\t box_type: %.4s limit: %d w:%d s:%d g:%d a:%d priority:%d\n", query_param.box_type[i], query_param.limit[i], query_param.w[i], query_param.s[i], query_param.g[i], query_param.a[i], query_param.priority[i]); |
| } |
| |
| fprintf( logstream, "\t root-bin: %d\n", query_param.root_bin); |
| fprintf( logstream, "\t max-depth: %d\n", query_param.max_depth); |
| fprintf( logstream, "\t metadata-only: %d\n", query_param.metadata_only); |
| fprintf( logstream, "\t image return type: %d, [JPP-stream=0, JPT-stream=1, UNKNOWN=-1]\n", query_param.return_type); |
| fprintf( logstream, "\t len: %d\n", query_param.len); |
| } |
| |
| void parse_cclose( char *src, query_param_t *query_param) |
| { |
| size_t i; |
| size_t len; |
| |
| len = strlen( src); |
| query_param->cclose = strdup( src); |
| |
| for( i=0; i<len; i++) |
| if( query_param->cclose[i] == ',') { |
| query_param->cclose[i] = '\0'; |
| query_param->numOfcclose ++; |
| } |
| |
| query_param->numOfcclose ++; |
| } |
| |
| void parse_req_box_prop( char *req_box_prop, int idx, query_param_t *query_param); |
| |
| void parse_metareq( char *field, query_param_t *query_param) |
| { |
| char req_box_prop[20]; |
| char *ptr, *src; |
| int numofboxreq = 0; |
| |
| memset( req_box_prop, 0, 20); |
| |
| /* req-box-prop*/ |
| ptr = strchr( field, '['); |
| ptr++; |
| src = ptr; |
| while( *ptr != ']') { |
| if( *ptr == ';') { |
| assert( ptr-src >= 0); |
| strncpy( req_box_prop, src, (size_t)(ptr-src)); |
| parse_req_box_prop( req_box_prop, numofboxreq++, query_param); |
| ptr++; |
| src = ptr; |
| memset( req_box_prop, 0, 20); |
| } |
| ptr++; |
| } |
| assert(ptr-src>=0); |
| strncpy( req_box_prop, src, (size_t)(ptr-src)); |
| |
| parse_req_box_prop( req_box_prop, numofboxreq++, query_param); |
| |
| if(( ptr = strchr( field, 'R'))) |
| sscanf( ptr+1, "%d", &(query_param->root_bin)); |
| |
| if(( ptr = strchr( field, 'D'))) |
| sscanf( ptr+1, "%d", &(query_param->max_depth)); |
| |
| if(( ptr = strstr( field, "!!"))) |
| query_param->metadata_only = OPJ_TRUE; |
| } |
| |
| void parse_req_box_prop( char *req_box_prop, int idx, query_param_t *query_param) |
| { |
| char *ptr; |
| |
| if( *req_box_prop == '*') |
| query_param->box_type[idx][0]='*'; |
| else |
| strncpy( query_param->box_type[idx], req_box_prop, 4); |
| |
| if(( ptr = strchr( req_box_prop, ':'))) { |
| if( *(ptr+1)=='r') |
| query_param->limit[idx] = -1; |
| else |
| sscanf( ptr+1, "%d", &(query_param->limit[idx])); |
| } |
| |
| if(( ptr = strchr( req_box_prop, '/'))) { |
| ptr++; |
| while( *ptr=='w' || *ptr=='s' || *ptr=='g' || *ptr=='a') { |
| switch( *ptr) { |
| case 'w': |
| query_param->w[idx] = OPJ_TRUE; |
| break; |
| case 's': |
| query_param->s[idx] = OPJ_TRUE; |
| break; |
| case 'g': |
| query_param->g[idx] = OPJ_TRUE; |
| break; |
| case 'a': |
| query_param->a[idx] = OPJ_TRUE; |
| break; |
| } |
| ptr++; |
| } |
| } else { |
| query_param->g[idx] = OPJ_TRUE; |
| query_param->s[idx] = OPJ_TRUE; |
| query_param->w[idx] = OPJ_TRUE; |
| } |
| |
| if((ptr = strchr( req_box_prop, '!'))) |
| query_param->priority[idx] = OPJ_TRUE; |
| |
| idx++; |
| } |
| |
| void parse_comps( char *field, query_param_t *query_param) |
| { |
| int i,start,stop,aux = -1; |
| char *ptr1,*ptr2; |
| |
| ptr1 = strchr( field, '-'); |
| ptr2 = strchr( field, ','); |
| |
| if( ptr1 && ptr2) |
| if( ptr1 > ptr2) |
| sscanf( field, "%d,%d-%d",&aux, &start, &stop); |
| else |
| sscanf( field, "%d-%d,%d", &start, &stop, &aux); |
| else if(ptr1) |
| sscanf( field, "%d-%d", &start, &stop); |
| else if(ptr2) { |
| sscanf( field, "%d,%d", &start, &stop); |
| aux = start; |
| start = stop; |
| } else { |
| sscanf( field, "%d", &stop); |
| start = stop; |
| } |
| |
| query_param->lastcomp = stop > aux ? stop : aux; |
| query_param->comps = (OPJ_BOOL *)opj_calloc( 1, (OPJ_SIZE_T)(query_param->lastcomp+1)*sizeof(OPJ_BOOL)); |
| |
| for( i=start; i<=stop; i++) |
| query_param->comps[i]=OPJ_TRUE; |
| |
| if(aux!=-1) |
| query_param->comps[aux] = OPJ_TRUE; |
| } |
| |
| void delete_query( query_param_t **query) |
| { |
| if( (*query)->target) |
| opj_free( (*query)->target); |
| |
| if( (*query)->tid) |
| opj_free( (*query)->tid); |
| |
| if( (*query)->comps) |
| opj_free((*query)->comps); |
| |
| if( (*query)->cid) |
| opj_free( (*query)->cid); |
| |
| if( (*query)->cclose) |
| opj_free( (*query)->cclose); |
| |
| opj_free( *query); |
| } |
