-/* ------------------------------------------------
-Copyright 2014 AT&T Intellectual Property
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- ------------------------------------------- */
-
-#include"schemaparser_impl.h"
-#include"schemaparser.h"
-#include <string>
-#include "parse_fta.h"
-#include "parse_schema.h"
-#include"generate_utils.h"
-
-#include"host_tuple.h"
-#include"lapp.h"
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-
-// Interface to FTA definition lexer and parser ...
-
-extern int FtaParserparse(void);
-extern FILE *FtaParserin;
-extern int FtaParserdebug;
-
-// This will need to be moved to a parse_fta.cc file.
-fta_parse_t *fta_parse_result;
-var_defs_t *fta_parse_defines;
-
-
-
-using namespace std;
-extern int errno;
-
-static gs_int8_t tmpstr[20000]; // for returning const char* values.
-
-vector<query_rep *> schema_list; // The schemas parsed thus far.
-
-/////////////////////////////////////////////////////////////
-/// Version functions
-
-static gs_int32_t curr_version = 4;
-static gs_int32_t accepted_versions[] = { 4, 3, 2, 1, 0 }; // must end with zero.
-
-gs_int32_t get_schemaparser_version(){ return curr_version; }
-
-gs_int32_t *get_schemaparser_accepted_versions(){return accepted_versions;}
-
-gs_int32_t schemaparser_accepts_version(gs_int32_t v){
- int i;
- for(i=0;accepted_versions[i]>0;++i){
- if(accepted_versions[i] == v) return 1;
- }
- return 0;
-}
-
-
-/////////////////////////////////////////////////////////////////////
-//////////// Utility Functions
-
-/*
-int fta_field_size(int dt, int *is_udef){
- switch(dt){
- case INT_TYPE:
- return(sizeof(int));
- case UINT_TYPE:
- case USHORT_TYPE:
- case BOOL_TYPE:
- return(sizeof(unsigned int));
- case ULLONG_TYPE:
- return(sizeof(unsigned long long int));
- case LLONG_TYPE:
- return(sizeof(long long int));
- case FLOAT_TYPE:
- return(sizeof(double));
- case TIMEVAL_TYPE:
- return(sizeof(timeval));
- case VSTR_TYPE:
- return(sizeof(vstring));
- default:
- *is_udef = 1;
- return(0);
- }
- return(0);
-};
-*/
-
-
-/////////////////////////////////////////////////////////////
-/// Interface fcns
-
-
-//////////// Schema management
-
-static gs_schemahandle_t ftaschema_parse(int prot_ok);
-
-gs_schemahandle_t ftaschema_parse_string(gs_csp_t f){
- // prot_ok is by default false in schemaparser.h
-
- fta_parse_result = new fta_parse_t();
- gs_sp_t schema = strdup(f);
-
-// FtaParserin = f;
- FtaParser_setstringinput(schema);
-
- if(FtaParserparse()){
- fprintf(stderr,"FTA parse failed.\n");
- free (schema);
- return(-1);
- }
- free (schema);
-
- return ftaschema_parse(false);
-}
-gs_schemahandle_t ftaschema_parse_string_prot(gs_csp_t f){
- // prot_ok is by default false in schemaparser.h
-
- fta_parse_result = new fta_parse_t();
- gs_sp_t schema = strdup(f);
-
-// FtaParserin = f;
- FtaParser_setstringinput(schema);
-
- if(FtaParserparse()){
- fprintf(stderr,"FTA parse failed.\n");
- free (schema);
- return(-1);
- }
- free (schema);
-
- return ftaschema_parse(true);
-}
-
-gs_schemahandle_t ftaschema_parse_file(FILE *f){
- // prot_ok is by default false in schemaparser.h
-
- fta_parse_result = new fta_parse_t();
-
-// FtaParserin = f;
- FtaParser_setfileinput(f);
-
- if(FtaParserparse()){
- fprintf(stderr,"FTA parse failed.\n");
- return(-1);
- }
-
- return ftaschema_parse(false);
-}
-gs_schemahandle_t ftaschema_parse_file_prot(FILE *f){
- // prot_ok is by default false in schemaparser.h
-
- fta_parse_result = new fta_parse_t();
-
-// FtaParserin = f;
- FtaParser_setfileinput(f);
-
- if(FtaParserparse()){
- fprintf(stderr,"FTA parse failed.\n");
- return(-1);
- }
-
- return ftaschema_parse(true);
-}
-
-
-
-
-
-static gs_schemahandle_t ftaschema_parse(int prot_ok){
-
- if(fta_parse_result->parse_type != STREAM_PARSE){
- if(!(fta_parse_result->parse_type == TABLE_PARSE && prot_ok!=0)){
- fprintf(stderr,"ERROR, input is not a stream file.\n");
- return(-1);
- }
- }
-
-
-// Get the tuple information.
- if(fta_parse_result->tables->size() != 1){
- fprintf(stderr,"ERROR parsing schema file: %d tables, expecting 1.\n",
- fta_parse_result->tables->size() );
- return(-1);
- }
-
- string table_name = fta_parse_result->tables->get_table_name(0);
- vector<field_entry *> tuple_flds = fta_parse_result->tables->get_fields(table_name);
- int n_tuples = tuple_flds.size();
-
-// get the parameter info.
- int n_params = 0;
- string query_name = table_name;
- vector<var_pair_t *> query_params;
- if(fta_parse_result->fta_parse_tree){
- query_params = fta_parse_result->fta_parse_tree->query_params;
- n_params = query_params.size();
-
-// Get the query name
- if(fta_parse_result->fta_parse_tree->nmap.count("query_name") == 0){
- fprintf(stderr,"WARNING: query name is empty. using default_query.\n");
- query_name = "default_query";
- }else{
- query_name = fta_parse_result->fta_parse_tree->nmap["query_name"];
- }
-
- if(query_name != table_name){
- fprintf(stderr,"WARNING table name (%s) is different than query name (%s).\n",
- table_name.c_str(), query_name.c_str() );
- }
-
- }
-
-// Construct the query representation.
-
- query_rep *qrep = new query_rep(query_name, n_tuples, n_params);
-
-// Pack the tuple information.
- int fi;
- for(fi=0;fi<n_tuples;++fi){
- if((qrep->set_field_info(fi,tuple_flds[fi])) == UNDEFINED_TYPE){
- fprintf(stderr,"ERROR tuple field %s (number %d) has undefined type %s.\n",
- tuple_flds[fi]->get_name().c_str(), fi, tuple_flds[fi]->get_type().c_str());
- }
- }
- if(qrep->finalize_field_info()){
- fprintf(stderr,"ERROR undefined type in tuple.\n");
- return(-1);
- }
-
-// Pack the param info
- int pi;
- for(pi=0;pi<n_params;++pi){
- if((qrep->set_param_info(pi, query_params[pi])) == UNDEFINED_TYPE){
- fprintf(stderr,"ERROR parameter %s (number %d) has undefined type %s.\n",
- query_params[pi]->name.c_str(), pi, query_params[pi]->val.c_str());
- }
- }
- if(qrep->finalize_param_info()){
- fprintf(stderr,"ERROR undefined type in parameter block.\n");
- return(-1);
- }
-
-// finish up
-
- schema_list.push_back(qrep);
-
- return(schema_list.size()-1);
-}
-
-
-/* Release memory used by the schema representation.
- return non-zero on error.
-*/
-// Currently, do nothing. I'll need to
-// systematically plug memory leaks and write destructors
-// to make implementing this function worth while.
-gs_int32_t ftaschema_free(gs_schemahandle_t sh){
- return(0);
-}
-
-
-/* name of fta schema null terminated */
-/* Returns NULL if sh is out of bounds. */
-/* NO ALLOCATION IS PERFORMED! Must treat result as const. */
-gs_sp_t ftaschema_name(gs_schemahandle_t sh){
- if(sh < 0 || sh >= schema_list.size()){
- return(NULL);
- }
- strcpy(tmpstr,schema_list[sh]->name.c_str());
- return(tmpstr);
-}
-
-
-///////////// Tuple management
-
-
-/* number of entries in a tuple */
-/* Return -1 if the schema handle is out of range. */
-gs_int32_t ftaschema_tuple_len(gs_schemahandle_t sh){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
- return(schema_list[sh]->field_info.size());
-}
-
-/* field entry name */
-/* Returns NULL if sh or index is out of bounds. */
-/* NO ALLOCATION IS PERFORMED! Must treat result as const. */
-gs_sp_t ftaschema_field_name(gs_schemahandle_t sh, gs_uint32_t index){
- if(sh < 0 || sh >= schema_list.size()){
- return(NULL);
- }
- if(index >= schema_list[sh]->field_info.size()){
- return(NULL);
- }
- strcpy(tmpstr,schema_list[sh]->field_info[index].field_name.c_str());
- return( tmpstr);
-}
-
-/* Direct tuple access functions.
-*/
-gs_uint32_t fta_unpack_uint(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
-// return(htonl(retval));
- return(retval);
-}
-gs_uint32_t fta_unpack_uint_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-
-gs_uint32_t fta_unpack_ushort(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
-// return(htonl(retval));
- return(retval);
-}
-gs_uint32_t fta_unpack_ushort_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-
-gs_uint32_t fta_unpack_bool(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
-// return(htonl(retval));
- return(retval);
-}
-gs_uint32_t fta_unpack_bool_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
-// return(htonl(retval));
- return(retval);
-}
-
-gs_int32_t fta_unpack_int(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_int32_t retval;
- if(offset+sizeof(gs_int32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));
-// return(htonl(retval));
- return(retval);
-}
-gs_int32_t fta_unpack_int_nocheck(void *data, gs_uint32_t offset){
- gs_int32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));
- return(retval);
-}
-
-gs_uint64_t fta_unpack_ullong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint64_t retval;
- if(offset+sizeof(gs_uint64_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));
-// return(htonll(retval));
- return(retval);
-}
-gs_uint64_t fta_unpack_ullong_nocheck(void *data, gs_uint32_t offset){
- gs_uint64_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));
- return(retval);
-}
-
-gs_int64_t fta_unpack_llong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_int64_t retval;
- if(offset+sizeof( gs_int64_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));
-// return(htonl(retval));
- return(retval);
-}
-gs_int64_t fta_unpack_llong_nocheck(void *data, gs_uint32_t offset){
- gs_int64_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));
- return(retval);
-}
-
-gs_float_t fta_unpack_float(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_float_t retval;
- if(offset+sizeof( gs_float_t) > len){
- *problem = 1;
- return(0.0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));
-// return(ntohf(retval));
- return(retval);
-}
-gs_float_t fta_unpack_float_nocheck(void *data, gs_uint32_t offset){
- gs_float_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));
- return(retval);
-}
-
-timeval fta_unpack_timeval(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- timeval retval;
- if(offset+sizeof( timeval) > len){
- *problem = 1;
- return(retval);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));
-// retval.tv_sec = htonl(retval.tv_sec);
-// retval.tv_usec = htonl(retval.tv_usec);
- retval.tv_sec = retval.tv_sec;
- retval.tv_usec = retval.tv_usec;
- return(retval);
-}
-timeval fta_unpack_timeval_nocheck(void *data, gs_uint32_t offset){
- timeval retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));
- retval.tv_sec = retval.tv_sec;
- retval.tv_usec = retval.tv_usec;
- return(retval);
-}
-
-vstring fta_unpack_vstr(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- vstring retval;
- vstring32 unpack_s;
-
- if(offset+sizeof( vstring32) > len){
- *problem = 1;
- return(retval);
- }
-
- memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));
-
-// retval.length = htonl(unpack_s.length);
-// unpack_s.offset = htonl(unpack_s.offset);
- retval.length = unpack_s.length;
- unpack_s.offset = unpack_s.offset;
- retval.reserved = SHALLOW_COPY;
-
- if(unpack_s.offset + retval.length > len){
- *problem = 1;
- return(retval);
- }
- retval.offset = (gs_p_t)data + unpack_s.offset;
- return(retval);
-}
-
-gs_sp_t fta_unpack_fstring(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- return( (gs_sp_t)(data)+offset);
-}
-
-struct hfta_ipv6_str fta_unpack_ipv6(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- struct hfta_ipv6_str retval;
- if(offset+sizeof(hfta_ipv6_str) > len){
- *problem = 1;
- return(retval);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));
-// htonl(retval.v[0]);
-// htonl(retval.v[1]);
-// htonl(retval.v[2]);
-// htonl(retval.v[3]);
- return(retval);
-}
-struct hfta_ipv6_str fta_unpack_ipv6_nocheck(void *data, gs_uint32_t offset){
- struct hfta_ipv6_str retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));
- return(retval);
-}
-
-
-/*
- Direct tuple access functions, but no ntoh xform.
-*/
-gs_uint32_t fta_unpack_uint_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-gs_uint32_t fta_unpack_uint_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-
-gs_uint32_t fta_unpack_ushort_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-gs_uint32_t fta_unpack_ushort_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-
-gs_uint32_t fta_unpack_bool_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_uint32_t retval;
- if(offset+sizeof(gs_uint32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-gs_uint32_t fta_unpack_bool_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_uint32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));
- return(retval);
-}
-
-gs_int32_t fta_unpack_int_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_int32_t retval;
- if(offset+sizeof(gs_int32_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));
- return(retval);
-}
-gs_int32_t fta_unpack_int_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_int32_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));
- return(retval);
-}
-
-gs_uint64_t fta_unpack_ullong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_int64_t retval;
- if(offset+sizeof( gs_uint64_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));
- return(retval);
-}
-gs_uint64_t fta_unpack_ullong_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_uint64_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));
- return(retval);
-}
-
-gs_int64_t fta_unpack_llong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_int64_t retval;
- if(offset+sizeof( gs_int64_t) > len){
- *problem = 1;
- return(0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));
- return(retval);
-}
-gs_int64_t fta_unpack_llong_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_int64_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));
- return(retval);
-}
-
-gs_float_t fta_unpack_float_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- gs_float_t retval;
- if(offset+sizeof( gs_float_t) > len){
- *problem = 1;
- return(0.0);
- }
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));
- return(retval);
-}
-gs_float_t fta_unpack_float_noxf_nocheck(void *data, gs_uint32_t offset){
- gs_float_t retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));
- return(retval);
-}
-
-timeval fta_unpack_timeval_noxf_nocheck(void *data, gs_uint32_t offset){
- timeval retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));
- return(retval);
-}
-
-vstring fta_unpack_vstr_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- vstring retval;
- vstring32 unpack_s;
-
- if(offset+sizeof( vstring32) > len){
- *problem = 1;
- return(retval);
- }
-
- memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));
-
- retval.length = unpack_s.length;
- retval.reserved = SHALLOW_COPY;
-
- if(unpack_s.offset + unpack_s.length > len){
- *problem = 1;
- return(retval);
- }
- retval.offset = (gs_p_t)data + unpack_s.offset;
- return(retval);
-}
-
-gs_sp_t fta_unpack_fstring_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){
- return( (gs_sp_t)(data)+offset);
-}
-
-struct hfta_ipv6_str fta_unpack_ipv6_noxf_nocheck(void *data, gs_uint32_t offset){
- struct hfta_ipv6_str retval;
- memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));
- return(retval);
-}
-
-
-/* returns fields offset by name */
-/* if sh is out of bounds, or if fieldname is not the name of a field,
- or len is too small,
- return value is -1
-*/
-gs_int32_t ftaschema_get_field_offset_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
-
- int f;
- for(f=0;f<schema_list[sh]->field_info.size();++f){
- if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)
- return(schema_list[sh]->field_info[f].offset);
- }
-
-// Nothing found
- return(-1);
-
-}
-/* field offset by index, return -1 if sh or idx is out-of-bounds */
-gs_int32_t ftaschema_get_field_offset_by_index(gs_schemahandle_t sh, gs_int32_t idx){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
- if(idx < 0 || idx >= schema_list[sh]->field_info.size()){
- return(-1);
- }
-
- return(schema_list[sh]->field_info[idx].offset);
-
-}
-
-
-/* returns fields type by name */
-/* if sh is out of bounds, or if fieldname is not the name of a field,
- or len is too small,
- return value is UNDEFINED_TYPE
-*/
-gs_int32_t ftaschema_get_field_type_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){
- if(sh < 0 || sh >= schema_list.size()){
- return(UNDEFINED_TYPE);
- }
-
- int f;
- for(f=0;f<schema_list[sh]->field_info.size();++f){
- if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)
- return(schema_list[sh]->field_info[f].pdt->type_indicator());
- }
-
-// Nothing found
- return( UNDEFINED_TYPE);
-}
-/* field type by index, rteturn value is UNDEFINED_TYPE if sh or idx
- * is out of bounds
-*/
-gs_int32_t ftaschema_get_field_type_by_index(gs_schemahandle_t sh, gs_int32_t idx){
- if(sh < 0 || sh >= schema_list.size()){
- return(UNDEFINED_TYPE);
- }
- if(idx < 0 || idx >= schema_list[sh]->field_info.size()){
- return(UNDEFINED_TYPE);
- }
-
- return(schema_list[sh]->field_info[idx].pdt->type_indicator());
-}
-
-
-/* returns tuple value based on name */
-/* if sh is out of bounds, or if fieldname is not the name of a field,
- or len is too small,
- return value is of type UNDEFINED_TYPE
-*/
-access_result ftaschema_get_field_by_name(gs_schemahandle_t sh, gs_csp_t fieldname,
- void * data, gs_uint32_t len){
- access_result retval;
- retval.field_data_type = UNDEFINED_TYPE;
-
- if(sh < 0 || sh >= schema_list.size()){
- return(retval);
- }
-
- int f;
- for(f=0;f<schema_list[sh]->field_info.size();++f){
- if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)
- return(ftaschema_get_field_by_index(sh,f,data,len));
- }
-
-// Nothing found
- return(retval);
-
-}
-
-/* return tuple value by index */
-/* if sh is out of bounds, or if fieldname is not the name of a field,
- or len is too small,
- return value is of type UNDEFINED_TYPE
-*/
-access_result ftaschema_get_field_by_index(gs_schemahandle_t sh, gs_uint32_t index,
- void * data, gs_uint32_t len){
- access_result retval;
- retval.field_data_type = UNDEFINED_TYPE;
- gs_int32_t problem = 0;
-
- if(sh < 0 || sh >= schema_list.size()){
- return(retval);
- }
- if(index >= schema_list[sh]->field_info.size()){
- return(retval);
- }
-
- switch(schema_list[sh]->field_info[index].pdt->get_type()){
- case u_int_t:
- retval.r.ui = fta_unpack_uint(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = UINT_TYPE;
- break;
- case ip_t:
- retval.r.ui = fta_unpack_uint(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = IP_TYPE;
- break;
- case int_t:
- retval.r.i = fta_unpack_int(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = INT_TYPE;
- break;
- case u_llong_t:
- retval.r.ul = fta_unpack_ullong(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = ULLONG_TYPE;
- break;
- case llong_t:
- retval.r.l = fta_unpack_llong(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = LLONG_TYPE;
- break;
- case u_short_t:
- retval.r.ui = fta_unpack_ushort(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = USHORT_TYPE;
- break;
- case floating_t:
- retval.r.f = fta_unpack_float(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = FLOAT_TYPE;
- break;
- case bool_t:
- retval.r.ui = fta_unpack_bool(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = BOOL_TYPE;
- break;
- case v_str_t:
- retval.r.vs = fta_unpack_vstr(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = VSTR_TYPE;
- break;
- case fstring_t:
- retval.r.fs.data = fta_unpack_fstring(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- retval.r.fs.size = schema_list[sh]->field_info[index].pdt->type_size();
- if(!problem) retval.field_data_type = FSTRING_TYPE;
- case timeval_t:
- retval.r.t = fta_unpack_timeval(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = TIMEVAL_TYPE;
- break;
- case ipv6_t:
- retval.r.ip6 = fta_unpack_ipv6(data, len,
- schema_list[sh]->field_info[index].offset, &problem);
- if(!problem) retval.field_data_type = IPV6_TYPE;
- break;
- case undefined_t:
- break;
- }
- return(retval);
-}
-
-
-// Get location of eof, temporal-tuple metadata.
-gs_int32_t ftaschema_get_tuple_metadata_offset(gs_schemahandle_t sh){
- if(sh < 0 || sh >= schema_list.size())
- return 0; // probably need to return a error instead of just telling its not eof tuple
-
- return ( schema_list[sh]->min_tuple_size);
-}
-
-
-/* checks whether tuple is temporal
- return value 1 indicates that tuple istemporal, 0 - not temporal
-*/
-gs_int32_t ftaschema_is_temporal_tuple(gs_schemahandle_t sh, void *data) {
-
- if(sh < 0 || sh >= schema_list.size())
- return 0; // probably need to return a error instead of just telling its not temporal
-
- return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == TEMPORAL_TUPLE);
-}
-//inline gs_int32_t ftaschema_is_temporal_tuple_offset(int metadata_offset, void *data) {
-// return (*((gs_sp_t)data + metadata_offset) == TEMPORAL_TUPLE);
-//}
-
-
-
-/* checks whether tuple is special end-of_file tuple
- return value 1 indicates that tuple is eof_tuple, 0 - otherwise
-*/
-gs_int32_t ftaschema_is_eof_tuple(gs_schemahandle_t sh, void *data) {
- if(sh < 0 || sh >= schema_list.size())
- return 0; // probably need to return a error instead of just telling its not eof tuple
-
- return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == EOF_TUPLE);
-
-}
-inline gs_int32_t ftaschema_is_eof_tuple_offset(int metadata_offset, void *data) {
- return (*((gs_sp_t)data + metadata_offset) == EOF_TUPLE);
-}
-
-
-/* extracts the trace from the temporal tuple
- return value 0 indicates success, non-zero - error
-*/
-gs_int32_t ftaschema_get_trace(gs_schemahandle_t sh, void* data, gs_int32_t len,
- gs_uint64_t* trace_id, gs_uint32_t* sz, fta_stat** trace ) {
-
- if(sh < 0 || sh >= schema_list.size() || *((gs_sp_t)data + schema_list[sh]->min_tuple_size) != TEMPORAL_TUPLE)
- return 1;
-
- memcpy(trace_id, (gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t), sizeof(gs_uint64_t));
- *trace = (fta_stat*)((gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t) + sizeof(gs_uint64_t));
- *sz = (len - schema_list[sh]->min_tuple_size - sizeof(gs_int8_t)- sizeof(gs_uint64_t)) / sizeof(fta_stat);
-
- return 0;
-}
-
-
-//////////// Param block management
-
-/* number of parameters */
-/* Return -1 if sh is out of bounds */
-gs_int32_t ftaschema_parameter_len(gs_schemahandle_t sh){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
- return(schema_list[sh]->param_info.size());
-}
-
-/* parameter entry name */
-/* Return NULL if sh or index is out of bounds. */
-/* NO COPYING IS PERFORMED */
-gs_sp_t ftaschema_parameter_name(gs_schemahandle_t sh, gs_uint32_t index){
- if(sh < 0 || sh >= schema_list.size()){
- return(NULL);
- }
- if(index >= schema_list[sh]->param_info.size()){
- return(NULL);
- }
- strcpy(tmpstr,schema_list[sh]->param_info[index].param_name.c_str());
- return(tmpstr);
-}
-
-/* set parameter value for parameter handle */
-/* Pass in the parameter in its char string representation. */
-/* Return value is -1 on error, else 0 */
-gs_int32_t ftaschema_setparam_by_name(gs_schemahandle_t sh, gs_sp_t param_name,
- gs_sp_t param_val, gs_int32_t len){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
-
- int f;
- for(f=0;f<schema_list[sh]->param_info.size();++f){
- if(strcmp(param_name, schema_list[sh]->param_info[f].param_name.c_str()) == 0)
- return(ftaschema_setparam_by_index(sh,f,param_val,len));
- }
-
-// not found
- return(-1);
-}
-
-/* set parameter value for parameter handle */
-/* Pass in the parameter in its char string representation. */
-/* Return value is -1 on error, else 0 */
-gs_int32_t ftaschema_setparam_by_index(gs_schemahandle_t sh, gs_int32_t index,
- gs_sp_t param_val, gs_int32_t len){
-
- void *tmp_ptr;
- unsigned int ui,d1,d2,d3,d4;
- int i;
- unsigned long long int ulli;
- long long int lli;
- double f;
-
-
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
- if(index >= schema_list[sh]->param_info.size()){
- return(-1);
- }
-
- param_block_info *pb = &(schema_list[sh]->param_info[index]);
- switch(pb->pdt->get_type()){
- case int_t:
- if(sscanf(param_val,"%d",&i) == 1){
- pb->value.r.i=i;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case u_int_t:
- case u_short_t:
- case bool_t:
- if(sscanf(param_val,"%u",&ui) == 1){
- pb->value.r.ui=ui;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case ip_t:
- if(sscanf(param_val,"%d.%d.%d.%d",&d1,&d2,&d3,&d4) == 4){
- pb->value.r.ui = (d1 << 24)+(d2 << 16)+(d3 << 8)+d4;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- case u_llong_t:
- if(sscanf(param_val,"%llu",&ulli) == 1){
- pb->value.r.ul=ulli;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case llong_t:
- if(sscanf(param_val,"%lld",&lli) == 1){
- pb->value.r.l=lli;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case floating_t:
- if(sscanf(param_val,"%lf",&f) == 1){
- pb->value.r.f=f;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case timeval_t:
- if(sscanf(param_val,"(%d,%d)",&d1, &d2) == 2){
- pb->value.r.t.tv_sec = d1;
- pb->value.r.t.tv_usec = d2;
- pb->value_set = true;
- return(0);
- }else
- return(-1);
- break;
- case v_str_t:
- if(pb->value.r.vs.offset != 0){
- tmp_ptr = (void *)(pb->value.r.vs.offset);
- free(tmp_ptr);
- }
- tmp_ptr = malloc(len);
- pb->value.r.vs.offset = (gs_p_t)tmp_ptr;
- memcpy(tmp_ptr,param_val, len);
- pb->value.r.vs.length = len;
-// pb->value.r.vs.reserved = 0;
- pb->value.r.vs.reserved = INTERNAL;
- pb->value_set = true;
- return(0);
- break;
- case fstring_t:
- fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");
- exit(1);
- break;
- case ipv6_t:
- fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");
- exit(1);
- break;
- case undefined_t:
- fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");
- exit(1);
- default:
- fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_setparam_by_index\n");
- exit(1);
- }
-
- return(-1);
-}
-
-gs_int32_t ftaschema_create_param_block(gs_schemahandle_t sh, void ** block, gs_int32_t * size){
- if(sh < 0 || sh >= schema_list.size()){
- return(-1);
- }
-
- *size = schema_list[sh]->min_param_size;
- int p;
-
- for(p=0;p<schema_list[sh]->param_info.size();++p){
- if(! schema_list[sh]->param_info[p].value_set) return 1;
-
- switch(schema_list[sh]->param_info[p].pdt->get_type()){
- case v_str_t:
- *size += schema_list[sh]->param_info[p].value.r.vs.length;
- break;
- case fstring_t:
- fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");
- exit(1);
- break;
- case undefined_t:
- return(-1);
- break;
- default:
- break;
- }
- }
-
- *block = malloc(*size);
- if(*block == NULL) return(-1);
-
- int data_pos = schema_list[sh]->min_param_size;
-
- gs_int32_t tmp_int;
- gs_uint32_t tmp_uint;
- gs_int64_t tmp_ll;
- gs_uint64_t tmp_ull;
- gs_float_t tmp_f;
- timeval tmp_tv;
- vstring32 tmp_vstr;
- void *tmp_ptr;
-
- for(p=0;p<schema_list[sh]->param_info.size();++p){
- param_block_info *pb = &(schema_list[sh]->param_info[p]);
- switch(pb->pdt->get_type()){
- case int_t:
-// tmp_int = htonl(pb->value.r.i);
- tmp_int = pb->value.r.i;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_int,sizeof(gs_int32_t));
- break;
- case u_int_t:
- case u_short_t:
- case bool_t:
- case ip_t:
-// tmp_uint = htonl(pb->value.r.ui);
- tmp_uint = pb->value.r.ui;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_uint,sizeof(gs_uint32_t));
- break;
- case u_llong_t:
-// tmp_ull = htonll(pb->value.r.ul);
- tmp_ull = pb->value.r.ul;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ull,sizeof(gs_uint64_t));
- break;
- case llong_t:
-// tmp_ll = htonll(pb->value.r.l);
- tmp_ll = pb->value.r.l;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ll,sizeof(gs_int64_t));
- break;
- case floating_t:
-// tmp_f = ntohf(pb->value.r.f);
- tmp_f = pb->value.r.f;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_f,sizeof(gs_float_t));
- break;
- case timeval_t:
-// tmp_tv.tv_sec = htonl(pb->value.r.t.tv_sec);
-// tmp_tv.tv_usec = htonl(pb->value.r.t.tv_usec);
- tmp_tv.tv_sec = pb->value.r.t.tv_sec;
- tmp_tv.tv_usec =pb->value.r.t.tv_usec;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_tv,sizeof(timeval));
- break;
- case v_str_t:
-// tmp_vstr.offset = htonl(data_pos);
-// tmp_vstr.length = htonl(pb->value.r.vs.length);
- tmp_vstr.offset = data_pos;
- tmp_vstr.length = pb->value.r.vs.length;
-// tmp_vstr.reserved = htonl(pb->value.r.vs.reserved);
-// tmp_vstr.reserved = htonl(PACKED);
- tmp_vstr.reserved = PACKED;
- memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_vstr,sizeof(vstring32));
- tmp_ptr = (void *)(pb->value.r.vs.offset);
- memcpy(((gs_sp_t)(*block))+data_pos, tmp_ptr, pb->value.r.vs.length);
- data_pos += pb->value.r.vs.length;
- break;
- case fstring_t:
- fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");
- exit(1);
- break;
- case ipv6_t:
- fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");
- exit(1);
- break;
- case undefined_t:
- fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");
- exit(1);
- default:
- fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_create_param_block\n");
- exit(1);
- }
- }
- return(0);
-
-}
-
-
-///////////////////////////////////////////////////////////////
-// Diagnostic functions
-
-void ftaschema_debugdump(gs_int32_t handle){
- if(handle<0){
- printf("ftaschema_debugdump: handle is negative.\n");
- return;
- }
- if(handle >= schema_list.size()){
- printf("ftaschema_debugdump: handle out of bounds (%d, max is %lu)\n",
- handle, schema_list.size());
- }
-
- query_rep *q = schema_list[handle];
-
- printf("Handle is %d, query name is <%s>\n",handle,q->name.c_str());
- printf("Output tuple has %lu fields:\n",q->field_info.size());
- int f;
- for(f=0;f<q->field_info.size();++f){
- printf("\t%s (%s) : %d\n",q->field_info[f].field_name.c_str(),
- (q->field_info[f].pdt->get_type_str()).c_str(),
- q->field_info[f].offset
- );
- }
- printf("Min tuple size is %d\n\n",q->min_tuple_size);
- printf("Param block is:\n");
- int p;
- for(p=0;p<q->param_info.size();++p){
- printf("\t%s (%s) : %d\n",q->param_info[p].param_name.c_str(),
- (q->param_info[p].pdt->get_type_str()).c_str(),
- q->param_info[p].offset
- );
- }
- printf("Min param block size is %d\n\n",q->min_param_size);
-
-
-
-}
-
-
+/* ------------------------------------------------\r
+Copyright 2014 AT&T Intellectual Property\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+ ------------------------------------------- */\r
+\r
+#include"schemaparser_impl.h"\r
+#include"schemaparser.h"\r
+#include <string>\r
+#include "parse_fta.h"\r
+#include "parse_schema.h"\r
+#include"generate_utils.h"\r
+\r
+#include"host_tuple.h"\r
+#include"lapp.h"\r
+\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+\r
+\r
+// Interface to FTA definition lexer and parser ...\r
+\r
+extern int FtaParserparse(void);\r
+extern FILE *FtaParserin;\r
+extern int FtaParserdebug;\r
+\r
+// This will need to be moved to a parse_fta.cc file.\r
+fta_parse_t *fta_parse_result;\r
+var_defs_t *fta_parse_defines;\r
+\r
+\r
+\r
+using namespace std;\r
+extern int errno;\r
+\r
+static gs_int8_t tmpstr[20000]; // for returning const char* values.\r
+\r
+vector<query_rep *> schema_list; // The schemas parsed thus far.\r
+\r
+/////////////////////////////////////////////////////////////\r
+/// Version functions\r
+\r
+static gs_int32_t curr_version = 4;\r
+static gs_int32_t accepted_versions[] = { 4, 3, 2, 1, 0 }; // must end with zero.\r
+\r
+gs_int32_t get_schemaparser_version(){ return curr_version; }\r
+\r
+gs_int32_t *get_schemaparser_accepted_versions(){return accepted_versions;}\r
+\r
+gs_int32_t schemaparser_accepts_version(gs_int32_t v){\r
+ int i;\r
+ for(i=0;accepted_versions[i]>0;++i){\r
+ if(accepted_versions[i] == v) return 1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+/////////////////////////////////////////////////////////////////////\r
+//////////// Utility Functions\r
+\r
+/*\r
+int fta_field_size(int dt, int *is_udef){\r
+ switch(dt){\r
+ case INT_TYPE:\r
+ return(sizeof(int));\r
+ case UINT_TYPE:\r
+ case USHORT_TYPE:\r
+ case BOOL_TYPE:\r
+ return(sizeof(unsigned int));\r
+ case ULLONG_TYPE:\r
+ return(sizeof(unsigned long long int));\r
+ case LLONG_TYPE:\r
+ return(sizeof(long long int));\r
+ case FLOAT_TYPE:\r
+ return(sizeof(double));\r
+ case TIMEVAL_TYPE:\r
+ return(sizeof(timeval));\r
+ case VSTR_TYPE:\r
+ return(sizeof(vstring));\r
+ default:\r
+ *is_udef = 1;\r
+ return(0);\r
+ }\r
+ return(0);\r
+};\r
+*/\r
+\r
+\r
+/////////////////////////////////////////////////////////////\r
+/// Interface fcns\r
+\r
+\r
+//////////// Schema management\r
+\r
+static gs_schemahandle_t ftaschema_parse(int prot_ok);\r
+\r
+gs_schemahandle_t ftaschema_parse_string(gs_csp_t f){\r
+ // prot_ok is by default false in schemaparser.h\r
+\r
+ fta_parse_result = new fta_parse_t();\r
+ gs_sp_t schema = strdup(f);\r
+\r
+// FtaParserin = f;\r
+ FtaParser_setstringinput(schema);\r
+\r
+ if(FtaParserparse()){\r
+ fprintf(stderr,"FTA parse failed.\n");\r
+ free (schema);\r
+ return(-1);\r
+ }\r
+ free (schema);\r
+\r
+ return ftaschema_parse(false);\r
+}\r
+gs_schemahandle_t ftaschema_parse_string_prot(gs_csp_t f){\r
+ // prot_ok is by default false in schemaparser.h\r
+\r
+ fta_parse_result = new fta_parse_t();\r
+ gs_sp_t schema = strdup(f);\r
+\r
+// FtaParserin = f;\r
+ FtaParser_setstringinput(schema);\r
+\r
+ if(FtaParserparse()){\r
+ fprintf(stderr,"FTA parse failed.\n");\r
+ free (schema);\r
+ return(-1);\r
+ }\r
+ free (schema);\r
+\r
+ return ftaschema_parse(true);\r
+}\r
+\r
+gs_schemahandle_t ftaschema_parse_file(FILE *f){\r
+ // prot_ok is by default false in schemaparser.h\r
+\r
+ fta_parse_result = new fta_parse_t();\r
+\r
+// FtaParserin = f;\r
+ FtaParser_setfileinput(f);\r
+\r
+ if(FtaParserparse()){\r
+ fprintf(stderr,"FTA parse failed.\n");\r
+ return(-1);\r
+ }\r
+\r
+ return ftaschema_parse(false);\r
+}\r
+gs_schemahandle_t ftaschema_parse_file_prot(FILE *f){\r
+ // prot_ok is by default false in schemaparser.h\r
+\r
+ fta_parse_result = new fta_parse_t();\r
+\r
+// FtaParserin = f;\r
+ FtaParser_setfileinput(f);\r
+\r
+ if(FtaParserparse()){\r
+ fprintf(stderr,"FTA parse failed.\n");\r
+ return(-1);\r
+ }\r
+\r
+ return ftaschema_parse(true);\r
+}\r
+\r
+\r
+\r
+\r
+\r
+static gs_schemahandle_t ftaschema_parse(int prot_ok){\r
+\r
+ if(fta_parse_result->parse_type != STREAM_PARSE){\r
+ if(!(fta_parse_result->parse_type == TABLE_PARSE && prot_ok!=0)){\r
+ fprintf(stderr,"ERROR, input is not a stream file.\n");\r
+ return(-1);\r
+ }\r
+ }\r
+\r
+\r
+// Get the tuple information.\r
+ if(fta_parse_result->tables->size() != 1){\r
+ fprintf(stderr,"ERROR parsing schema file: %d tables, expecting 1.\n",\r
+ fta_parse_result->tables->size() );\r
+ return(-1);\r
+ }\r
+\r
+ string table_name = fta_parse_result->tables->get_table_name(0);\r
+ vector<field_entry *> tuple_flds = fta_parse_result->tables->get_fields(table_name);\r
+ int n_tuples = tuple_flds.size();\r
+\r
+// get the parameter info.\r
+ int n_params = 0;\r
+ string query_name = table_name;\r
+ vector<var_pair_t *> query_params;\r
+ if(fta_parse_result->fta_parse_tree){\r
+ query_params = fta_parse_result->fta_parse_tree->query_params;\r
+ n_params = query_params.size();\r
+\r
+// Get the query name\r
+ if(fta_parse_result->fta_parse_tree->nmap.count("query_name") == 0){\r
+ fprintf(stderr,"WARNING: query name is empty. using default_query.\n");\r
+ query_name = "default_query";\r
+ }else{\r
+ query_name = fta_parse_result->fta_parse_tree->nmap["query_name"];\r
+ }\r
+\r
+ if(query_name != table_name){\r
+ fprintf(stderr,"WARNING table name (%s) is different than query name (%s).\n",\r
+ table_name.c_str(), query_name.c_str() );\r
+ }\r
+\r
+ }\r
+\r
+// Construct the query representation.\r
+\r
+ query_rep *qrep = new query_rep(query_name, n_tuples, n_params);\r
+\r
+// Pack the tuple information.\r
+ int fi;\r
+ for(fi=0;fi<n_tuples;++fi){\r
+ if((qrep->set_field_info(fi,tuple_flds[fi])) == UNDEFINED_TYPE){\r
+ fprintf(stderr,"ERROR tuple field %s (number %d) has undefined type %s.\n",\r
+ tuple_flds[fi]->get_name().c_str(), fi, tuple_flds[fi]->get_type().c_str());\r
+ }\r
+ }\r
+ if(qrep->finalize_field_info()){\r
+ fprintf(stderr,"ERROR undefined type in tuple.\n");\r
+ return(-1);\r
+ }\r
+\r
+// Pack the param info\r
+ int pi;\r
+ for(pi=0;pi<n_params;++pi){\r
+ if((qrep->set_param_info(pi, query_params[pi])) == UNDEFINED_TYPE){\r
+ fprintf(stderr,"ERROR parameter %s (number %d) has undefined type %s.\n",\r
+ query_params[pi]->name.c_str(), pi, query_params[pi]->val.c_str());\r
+ }\r
+ }\r
+ if(qrep->finalize_param_info()){\r
+ fprintf(stderr,"ERROR undefined type in parameter block.\n");\r
+ return(-1);\r
+ }\r
+\r
+// finish up\r
+\r
+ schema_list.push_back(qrep);\r
+\r
+ return(schema_list.size()-1);\r
+}\r
+\r
+\r
+/* Release memory used by the schema representation.\r
+ return non-zero on error.\r
+*/\r
+// Currently, do nothing. I'll need to\r
+// systematically plug memory leaks and write destructors\r
+// to make implementing this function worth while.\r
+gs_int32_t ftaschema_free(gs_schemahandle_t sh){\r
+ return(0);\r
+}\r
+\r
+\r
+/* name of fta schema null terminated */\r
+/* Returns NULL if sh is out of bounds. */\r
+/* NO ALLOCATION IS PERFORMED! Must treat result as const. */\r
+gs_sp_t ftaschema_name(gs_schemahandle_t sh){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(NULL);\r
+ }\r
+ strcpy(tmpstr,schema_list[sh]->name.c_str());\r
+ return(tmpstr);\r
+}\r
+\r
+\r
+///////////// Tuple management\r
+\r
+\r
+/* number of entries in a tuple */\r
+/* Return -1 if the schema handle is out of range. */\r
+gs_int32_t ftaschema_tuple_len(gs_schemahandle_t sh){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+ return(schema_list[sh]->field_info.size());\r
+}\r
+\r
+/* field entry name */\r
+/* Returns NULL if sh or index is out of bounds. */\r
+/* NO ALLOCATION IS PERFORMED! Must treat result as const. */\r
+gs_sp_t ftaschema_field_name(gs_schemahandle_t sh, gs_uint32_t index){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(NULL);\r
+ }\r
+ if(index >= schema_list[sh]->field_info.size()){\r
+ return(NULL);\r
+ }\r
+ strcpy(tmpstr,schema_list[sh]->field_info[index].field_name.c_str());\r
+ return( tmpstr);\r
+}\r
+\r
+/* Direct tuple access functions.\r
+*/\r
+gs_uint32_t fta_unpack_uint(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_uint_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint32_t fta_unpack_ushort(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_ushort_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint32_t fta_unpack_bool(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_bool_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+\r
+gs_int32_t fta_unpack_int(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_int32_t retval;\r
+ if(offset+sizeof(gs_int32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+gs_int32_t fta_unpack_int_nocheck(void *data, gs_uint32_t offset){\r
+ gs_int32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint64_t fta_unpack_ullong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint64_t retval;\r
+ if(offset+sizeof(gs_uint64_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
+// return(htonll(retval));\r
+ return(retval);\r
+}\r
+gs_uint64_t fta_unpack_ullong_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint64_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
+ return(retval);\r
+}\r
+\r
+gs_int64_t fta_unpack_llong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_int64_t retval;\r
+ if(offset+sizeof( gs_int64_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
+// return(htonl(retval));\r
+ return(retval);\r
+}\r
+gs_int64_t fta_unpack_llong_nocheck(void *data, gs_uint32_t offset){\r
+ gs_int64_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
+ return(retval);\r
+}\r
+\r
+gs_float_t fta_unpack_float(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_float_t retval;\r
+ if(offset+sizeof( gs_float_t) > len){\r
+ *problem = 1;\r
+ return(0.0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
+// return(ntohf(retval));\r
+ return(retval);\r
+}\r
+gs_float_t fta_unpack_float_nocheck(void *data, gs_uint32_t offset){\r
+ gs_float_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
+ return(retval);\r
+}\r
+\r
+timeval fta_unpack_timeval(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ timeval retval;\r
+ if(offset+sizeof( timeval) > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
+// retval.tv_sec = htonl(retval.tv_sec);\r
+// retval.tv_usec = htonl(retval.tv_usec);\r
+ retval.tv_sec = retval.tv_sec;\r
+ retval.tv_usec = retval.tv_usec;\r
+ return(retval);\r
+}\r
+timeval fta_unpack_timeval_nocheck(void *data, gs_uint32_t offset){\r
+ timeval retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
+ retval.tv_sec = retval.tv_sec;\r
+ retval.tv_usec = retval.tv_usec;\r
+ return(retval);\r
+}\r
+\r
+vstring fta_unpack_vstr(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ vstring retval;\r
+ vstring32 unpack_s;\r
+\r
+ if(offset+sizeof( vstring32) > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+\r
+ memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));\r
+\r
+// retval.length = htonl(unpack_s.length);\r
+// unpack_s.offset = htonl(unpack_s.offset);\r
+ retval.length = unpack_s.length;\r
+ unpack_s.offset = unpack_s.offset;\r
+ retval.reserved = SHALLOW_COPY;\r
+\r
+ if(unpack_s.offset + retval.length > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+ retval.offset = (gs_p_t)data + unpack_s.offset;\r
+ return(retval);\r
+}\r
+\r
+gs_sp_t fta_unpack_fstring(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ return( (gs_sp_t)(data)+offset);\r
+}\r
+\r
+struct hfta_ipv6_str fta_unpack_ipv6(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ struct hfta_ipv6_str retval;\r
+ if(offset+sizeof(hfta_ipv6_str) > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
+// htonl(retval.v[0]);\r
+// htonl(retval.v[1]);\r
+// htonl(retval.v[2]);\r
+// htonl(retval.v[3]);\r
+ return(retval);\r
+}\r
+struct hfta_ipv6_str fta_unpack_ipv6_nocheck(void *data, gs_uint32_t offset){\r
+ struct hfta_ipv6_str retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
+ return(retval);\r
+}\r
+\r
+\r
+/*\r
+ Direct tuple access functions, but no ntoh xform.\r
+*/\r
+gs_uint32_t fta_unpack_uint_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_uint_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint32_t fta_unpack_ushort_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_ushort_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint32_t fta_unpack_bool_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_uint32_t retval;\r
+ if(offset+sizeof(gs_uint32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+gs_uint32_t fta_unpack_bool_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_int32_t fta_unpack_int_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_int32_t retval;\r
+ if(offset+sizeof(gs_int32_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
+ return(retval);\r
+}\r
+gs_int32_t fta_unpack_int_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_int32_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
+ return(retval);\r
+}\r
+\r
+gs_uint64_t fta_unpack_ullong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_int64_t retval;\r
+ if(offset+sizeof( gs_uint64_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
+ return(retval);\r
+}\r
+gs_uint64_t fta_unpack_ullong_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_uint64_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
+ return(retval);\r
+}\r
+\r
+gs_int64_t fta_unpack_llong_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_int64_t retval;\r
+ if(offset+sizeof( gs_int64_t) > len){\r
+ *problem = 1;\r
+ return(0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
+ return(retval);\r
+}\r
+gs_int64_t fta_unpack_llong_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_int64_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
+ return(retval);\r
+}\r
+\r
+gs_float_t fta_unpack_float_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ gs_float_t retval;\r
+ if(offset+sizeof( gs_float_t) > len){\r
+ *problem = 1;\r
+ return(0.0);\r
+ }\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
+ return(retval);\r
+}\r
+gs_float_t fta_unpack_float_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ gs_float_t retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
+ return(retval);\r
+}\r
+\r
+timeval fta_unpack_timeval_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ timeval retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
+ return(retval);\r
+}\r
+\r
+vstring fta_unpack_vstr_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ vstring retval;\r
+ vstring32 unpack_s;\r
+\r
+ if(offset+sizeof( vstring32) > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+\r
+ memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));\r
+\r
+ retval.length = unpack_s.length;\r
+ retval.reserved = SHALLOW_COPY;\r
+\r
+ if(unpack_s.offset + unpack_s.length > len){\r
+ *problem = 1;\r
+ return(retval);\r
+ }\r
+ retval.offset = (gs_p_t)data + unpack_s.offset;\r
+ return(retval);\r
+}\r
+\r
+gs_sp_t fta_unpack_fstring_noxf(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
+ return( (gs_sp_t)(data)+offset);\r
+}\r
+\r
+struct hfta_ipv6_str fta_unpack_ipv6_noxf_nocheck(void *data, gs_uint32_t offset){\r
+ struct hfta_ipv6_str retval;\r
+ memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
+ return(retval);\r
+}\r
+\r
+\r
+/* returns fields offset by name */\r
+/* if sh is out of bounds, or if fieldname is not the name of a field,\r
+ or len is too small,\r
+ return value is -1\r
+*/\r
+gs_int32_t ftaschema_get_field_offset_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+\r
+ int f;\r
+ for(f=0;f<schema_list[sh]->field_info.size();++f){\r
+ if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
+ return(schema_list[sh]->field_info[f].offset);\r
+ }\r
+\r
+// Nothing found\r
+ return(-1);\r
+\r
+}\r
+/* field offset by index, return -1 if sh or idx is out-of-bounds */\r
+gs_int32_t ftaschema_get_field_offset_by_index(gs_schemahandle_t sh, gs_int32_t idx){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+ if(idx < 0 || idx >= schema_list[sh]->field_info.size()){\r
+ return(-1);\r
+ }\r
+\r
+ return(schema_list[sh]->field_info[idx].offset);\r
+\r
+}\r
+\r
+\r
+/* returns fields type by name */\r
+/* if sh is out of bounds, or if fieldname is not the name of a field,\r
+ or len is too small,\r
+ return value is UNDEFINED_TYPE\r
+*/\r
+gs_int32_t ftaschema_get_field_type_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(UNDEFINED_TYPE);\r
+ }\r
+\r
+ int f;\r
+ for(f=0;f<schema_list[sh]->field_info.size();++f){\r
+ if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
+ return(schema_list[sh]->field_info[f].pdt->type_indicator());\r
+ }\r
+\r
+// Nothing found\r
+ return( UNDEFINED_TYPE);\r
+}\r
+/* field type by index, rteturn value is UNDEFINED_TYPE if sh or idx \r
+ * is out of bounds\r
+*/\r
+gs_int32_t ftaschema_get_field_type_by_index(gs_schemahandle_t sh, gs_int32_t idx){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(UNDEFINED_TYPE);\r
+ }\r
+ if(idx < 0 || idx >= schema_list[sh]->field_info.size()){\r
+ return(UNDEFINED_TYPE);\r
+ }\r
+\r
+ return(schema_list[sh]->field_info[idx].pdt->type_indicator());\r
+}\r
+\r
+\r
+/* returns tuple value based on name */\r
+/* if sh is out of bounds, or if fieldname is not the name of a field,\r
+ or len is too small,\r
+ return value is of type UNDEFINED_TYPE\r
+*/\r
+access_result ftaschema_get_field_by_name(gs_schemahandle_t sh, gs_csp_t fieldname,\r
+ void * data, gs_uint32_t len){\r
+ access_result retval;\r
+ retval.field_data_type = UNDEFINED_TYPE;\r
+\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(retval);\r
+ }\r
+\r
+ int f;\r
+ for(f=0;f<schema_list[sh]->field_info.size();++f){\r
+ if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
+ return(ftaschema_get_field_by_index(sh,f,data,len));\r
+ }\r
+\r
+// Nothing found\r
+ return(retval);\r
+\r
+}\r
+\r
+/* return tuple value by index */\r
+/* if sh is out of bounds, or if fieldname is not the name of a field,\r
+ or len is too small,\r
+ return value is of type UNDEFINED_TYPE\r
+*/\r
+access_result ftaschema_get_field_by_index(gs_schemahandle_t sh, gs_uint32_t index,\r
+ void * data, gs_uint32_t len){\r
+ access_result retval;\r
+ retval.field_data_type = UNDEFINED_TYPE;\r
+ gs_int32_t problem = 0;\r
+\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(retval);\r
+ }\r
+ if(index >= schema_list[sh]->field_info.size()){\r
+ return(retval);\r
+ }\r
+\r
+ switch(schema_list[sh]->field_info[index].pdt->get_type()){\r
+ case u_int_t:\r
+ retval.r.ui = fta_unpack_uint(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = UINT_TYPE;\r
+ break;\r
+ case ip_t:\r
+ retval.r.ui = fta_unpack_uint(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = IP_TYPE;\r
+ break;\r
+ case int_t:\r
+ retval.r.i = fta_unpack_int(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = INT_TYPE;\r
+ break;\r
+ case u_llong_t:\r
+ retval.r.ul = fta_unpack_ullong(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = ULLONG_TYPE;\r
+ break;\r
+ case llong_t:\r
+ retval.r.l = fta_unpack_llong(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = LLONG_TYPE;\r
+ break;\r
+ case u_short_t:\r
+ retval.r.ui = fta_unpack_ushort(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = USHORT_TYPE;\r
+ break;\r
+ case floating_t:\r
+ retval.r.f = fta_unpack_float(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = FLOAT_TYPE;\r
+ break;\r
+ case bool_t:\r
+ retval.r.ui = fta_unpack_bool(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = BOOL_TYPE;\r
+ break;\r
+ case v_str_t:\r
+ retval.r.vs = fta_unpack_vstr(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = VSTR_TYPE;\r
+ break;\r
+ case fstring_t:\r
+ retval.r.fs.data = fta_unpack_fstring(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ retval.r.fs.size = schema_list[sh]->field_info[index].pdt->type_size();\r
+ if(!problem) retval.field_data_type = FSTRING_TYPE;\r
+ case timeval_t:\r
+ retval.r.t = fta_unpack_timeval(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = TIMEVAL_TYPE;\r
+ break;\r
+ case ipv6_t:\r
+ retval.r.ip6 = fta_unpack_ipv6(data, len,\r
+ schema_list[sh]->field_info[index].offset, &problem);\r
+ if(!problem) retval.field_data_type = IPV6_TYPE;\r
+ break;\r
+ case undefined_t:\r
+ break;\r
+ }\r
+ return(retval);\r
+}\r
+\r
+\r
+// Get location of eof, temporal-tuple metadata.\r
+gs_int32_t ftaschema_get_tuple_metadata_offset(gs_schemahandle_t sh){\r
+ if(sh < 0 || sh >= schema_list.size())\r
+ return 0; // probably need to return a error instead of just telling its not eof tuple\r
+\r
+ return ( schema_list[sh]->min_tuple_size);\r
+}\r
+\r
+\r
+/* checks whether tuple is temporal\r
+ return value 1 indicates that tuple istemporal, 0 - not temporal\r
+*/\r
+gs_int32_t ftaschema_is_temporal_tuple(gs_schemahandle_t sh, void *data) {\r
+\r
+ if(sh < 0 || sh >= schema_list.size())\r
+ return 0; // probably need to return a error instead of just telling its not temporal\r
+\r
+ return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == TEMPORAL_TUPLE);\r
+}\r
+//inline gs_int32_t ftaschema_is_temporal_tuple_offset(int metadata_offset, void *data) {\r
+// return (*((gs_sp_t)data + metadata_offset) == TEMPORAL_TUPLE);\r
+//}\r
+\r
+\r
+\r
+/* checks whether tuple is special end-of_file tuple\r
+ return value 1 indicates that tuple is eof_tuple, 0 - otherwise\r
+*/\r
+gs_int32_t ftaschema_is_eof_tuple(gs_schemahandle_t sh, void *data) {\r
+ if(sh < 0 || sh >= schema_list.size())\r
+ return 0; // probably need to return a error instead of just telling its not eof tuple\r
+\r
+ return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == EOF_TUPLE);\r
+\r
+}\r
+inline gs_int32_t ftaschema_is_eof_tuple_offset(int metadata_offset, void *data) {\r
+ return (*((gs_sp_t)data + metadata_offset) == EOF_TUPLE);\r
+}\r
+\r
+\r
+/* extracts the trace from the temporal tuple\r
+ return value 0 indicates success, non-zero - error\r
+*/\r
+gs_int32_t ftaschema_get_trace(gs_schemahandle_t sh, void* data, gs_int32_t len,\r
+ gs_uint64_t* trace_id, gs_uint32_t* sz, fta_stat** trace ) {\r
+\r
+ if(sh < 0 || sh >= schema_list.size() || *((gs_sp_t)data + schema_list[sh]->min_tuple_size) != TEMPORAL_TUPLE)\r
+ return 1;\r
+\r
+ memcpy(trace_id, (gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t), sizeof(gs_uint64_t));\r
+ *trace = (fta_stat*)((gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t) + sizeof(gs_uint64_t));\r
+ *sz = (len - schema_list[sh]->min_tuple_size - sizeof(gs_int8_t)- sizeof(gs_uint64_t)) / sizeof(fta_stat);\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+//////////// Param block management\r
+\r
+/* number of parameters */\r
+/* Return -1 if sh is out of bounds */\r
+gs_int32_t ftaschema_parameter_len(gs_schemahandle_t sh){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+ return(schema_list[sh]->param_info.size());\r
+}\r
+\r
+/* parameter entry name */\r
+/* Return NULL if sh or index is out of bounds. */\r
+/* NO COPYING IS PERFORMED */\r
+gs_sp_t ftaschema_parameter_name(gs_schemahandle_t sh, gs_uint32_t index){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(NULL);\r
+ }\r
+ if(index >= schema_list[sh]->param_info.size()){\r
+ return(NULL);\r
+ }\r
+ strcpy(tmpstr,schema_list[sh]->param_info[index].param_name.c_str());\r
+ return(tmpstr);\r
+}\r
+\r
+/* set parameter value for parameter handle */\r
+/* Pass in the parameter in its char string representation. */\r
+/* Return value is -1 on error, else 0 */\r
+gs_int32_t ftaschema_setparam_by_name(gs_schemahandle_t sh, gs_sp_t param_name,\r
+ gs_sp_t param_val, gs_int32_t len){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+\r
+ int f;\r
+ for(f=0;f<schema_list[sh]->param_info.size();++f){\r
+ if(strcmp(param_name, schema_list[sh]->param_info[f].param_name.c_str()) == 0)\r
+ return(ftaschema_setparam_by_index(sh,f,param_val,len));\r
+ }\r
+\r
+// not found\r
+ return(-1);\r
+}\r
+\r
+/* set parameter value for parameter handle */\r
+/* Pass in the parameter in its char string representation. */\r
+/* Return value is -1 on error, else 0 */\r
+gs_int32_t ftaschema_setparam_by_index(gs_schemahandle_t sh, gs_int32_t index,\r
+ gs_sp_t param_val, gs_int32_t len){\r
+\r
+ void *tmp_ptr;\r
+ unsigned int ui,d1,d2,d3,d4;\r
+ int i;\r
+ unsigned long long int ulli;\r
+ long long int lli;\r
+ double f;\r
+\r
+\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+ if(index >= schema_list[sh]->param_info.size()){\r
+ return(-1);\r
+ }\r
+\r
+ param_block_info *pb = &(schema_list[sh]->param_info[index]);\r
+ switch(pb->pdt->get_type()){\r
+ case int_t:\r
+ if(sscanf(param_val,"%d",&i) == 1){\r
+ pb->value.r.i=i;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case u_int_t:\r
+ case u_short_t:\r
+ case bool_t:\r
+ if(sscanf(param_val,"%u",&ui) == 1){\r
+ pb->value.r.ui=ui;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case ip_t:\r
+ if(sscanf(param_val,"%d.%d.%d.%d",&d1,&d2,&d3,&d4) == 4){\r
+ pb->value.r.ui = (d1 << 24)+(d2 << 16)+(d3 << 8)+d4;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ case u_llong_t:\r
+ if(sscanf(param_val,"%llu",&ulli) == 1){\r
+ pb->value.r.ul=ulli;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case llong_t:\r
+ if(sscanf(param_val,"%lld",&lli) == 1){\r
+ pb->value.r.l=lli;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case floating_t:\r
+ if(sscanf(param_val,"%lf",&f) == 1){\r
+ pb->value.r.f=f;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case timeval_t:\r
+ if(sscanf(param_val,"(%d,%d)",&d1, &d2) == 2){\r
+ pb->value.r.t.tv_sec = d1;\r
+ pb->value.r.t.tv_usec = d2;\r
+ pb->value_set = true;\r
+ return(0);\r
+ }else\r
+ return(-1);\r
+ break;\r
+ case v_str_t:\r
+ if(pb->value.r.vs.offset != 0){\r
+ tmp_ptr = (void *)(pb->value.r.vs.offset);\r
+ free(tmp_ptr);\r
+ }\r
+ tmp_ptr = malloc(len);\r
+ pb->value.r.vs.offset = (gs_p_t)tmp_ptr;\r
+ memcpy(tmp_ptr,param_val, len);\r
+ pb->value.r.vs.length = len;\r
+// pb->value.r.vs.reserved = 0;\r
+ pb->value.r.vs.reserved = INTERNAL;\r
+ pb->value_set = true;\r
+ return(0);\r
+ break;\r
+ case fstring_t:\r
+ fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
+ exit(1);\r
+ break;\r
+ case ipv6_t:\r
+ fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");\r
+ exit(1);\r
+ break;\r
+ case undefined_t:\r
+ fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");\r
+ exit(1);\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_setparam_by_index\n");\r
+ exit(1);\r
+ }\r
+\r
+ return(-1);\r
+}\r
+\r
+gs_int32_t ftaschema_create_param_block(gs_schemahandle_t sh, void ** block, gs_int32_t * size){\r
+ if(sh < 0 || sh >= schema_list.size()){\r
+ return(-1);\r
+ }\r
+\r
+ *size = schema_list[sh]->min_param_size;\r
+ int p;\r
+\r
+ for(p=0;p<schema_list[sh]->param_info.size();++p){\r
+ if(! schema_list[sh]->param_info[p].value_set) return 1;\r
+\r
+ switch(schema_list[sh]->param_info[p].pdt->get_type()){\r
+ case v_str_t:\r
+ *size += schema_list[sh]->param_info[p].value.r.vs.length;\r
+ break;\r
+ case fstring_t:\r
+ fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
+ exit(1);\r
+ break;\r
+ case undefined_t:\r
+ return(-1);\r
+ break;\r
+ default:\r
+ break;\r
+ }\r
+ }\r
+\r
+ *block = malloc(*size);\r
+ if(*block == NULL) return(-1);\r
+\r
+ int data_pos = schema_list[sh]->min_param_size;\r
+\r
+ gs_int32_t tmp_int;\r
+ gs_uint32_t tmp_uint;\r
+ gs_int64_t tmp_ll;\r
+ gs_uint64_t tmp_ull;\r
+ gs_float_t tmp_f;\r
+ timeval tmp_tv;\r
+ vstring32 tmp_vstr;\r
+ void *tmp_ptr;\r
+\r
+ for(p=0;p<schema_list[sh]->param_info.size();++p){\r
+ param_block_info *pb = &(schema_list[sh]->param_info[p]);\r
+ switch(pb->pdt->get_type()){\r
+ case int_t:\r
+// tmp_int = htonl(pb->value.r.i);\r
+ tmp_int = pb->value.r.i;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_int,sizeof(gs_int32_t));\r
+ break;\r
+ case u_int_t:\r
+ case u_short_t:\r
+ case bool_t:\r
+ case ip_t:\r
+// tmp_uint = htonl(pb->value.r.ui);\r
+ tmp_uint = pb->value.r.ui;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_uint,sizeof(gs_uint32_t));\r
+ break;\r
+ case u_llong_t:\r
+// tmp_ull = htonll(pb->value.r.ul);\r
+ tmp_ull = pb->value.r.ul;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ull,sizeof(gs_uint64_t));\r
+ break;\r
+ case llong_t:\r
+// tmp_ll = htonll(pb->value.r.l);\r
+ tmp_ll = pb->value.r.l;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ll,sizeof(gs_int64_t));\r
+ break;\r
+ case floating_t:\r
+// tmp_f = ntohf(pb->value.r.f);\r
+ tmp_f = pb->value.r.f;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_f,sizeof(gs_float_t));\r
+ break;\r
+ case timeval_t:\r
+// tmp_tv.tv_sec = htonl(pb->value.r.t.tv_sec);\r
+// tmp_tv.tv_usec = htonl(pb->value.r.t.tv_usec);\r
+ tmp_tv.tv_sec = pb->value.r.t.tv_sec;\r
+ tmp_tv.tv_usec =pb->value.r.t.tv_usec;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_tv,sizeof(timeval));\r
+ break;\r
+ case v_str_t:\r
+// tmp_vstr.offset = htonl(data_pos);\r
+// tmp_vstr.length = htonl(pb->value.r.vs.length);\r
+ tmp_vstr.offset = data_pos;\r
+ tmp_vstr.length = pb->value.r.vs.length;\r
+// tmp_vstr.reserved = htonl(pb->value.r.vs.reserved);\r
+// tmp_vstr.reserved = htonl(PACKED);\r
+ tmp_vstr.reserved = PACKED;\r
+ memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_vstr,sizeof(vstring32));\r
+ tmp_ptr = (void *)(pb->value.r.vs.offset);\r
+ memcpy(((gs_sp_t)(*block))+data_pos, tmp_ptr, pb->value.r.vs.length);\r
+ data_pos += pb->value.r.vs.length;\r
+ break;\r
+ case fstring_t:\r
+ fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
+ exit(1);\r
+ break;\r
+ case ipv6_t:\r
+ fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");\r
+ exit(1);\r
+ break;\r
+ case undefined_t:\r
+ fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");\r
+ exit(1);\r
+ default:\r
+ fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_create_param_block\n");\r
+ exit(1);\r
+ }\r
+ }\r
+ return(0);\r
+\r
+}\r
+\r
+\r
+///////////////////////////////////////////////////////////////\r
+// Diagnostic functions\r
+\r
+void ftaschema_debugdump(gs_int32_t handle){\r
+ if(handle<0){\r
+ printf("ftaschema_debugdump: handle is negative.\n");\r
+ return;\r
+ }\r
+ if(handle >= schema_list.size()){\r
+ printf("ftaschema_debugdump: handle out of bounds (%d, max is %lu)\n",\r
+ handle, schema_list.size());\r
+ }\r
+\r
+ query_rep *q = schema_list[handle];\r
+\r
+ printf("Handle is %d, query name is <%s>\n",handle,q->name.c_str());\r
+ printf("Output tuple has %lu fields:\n",q->field_info.size());\r
+ int f;\r
+ for(f=0;f<q->field_info.size();++f){\r
+ printf("\t%s (%s) : %d\n",q->field_info[f].field_name.c_str(),\r
+ (q->field_info[f].pdt->get_type_str()).c_str(),\r
+ q->field_info[f].offset\r
+ );\r
+ }\r
+ printf("Min tuple size is %d\n\n",q->min_tuple_size);\r
+ printf("Param block is:\n");\r
+ int p;\r
+ for(p=0;p<q->param_info.size();++p){\r
+ printf("\t%s (%s) : %d\n",q->param_info[p].param_name.c_str(),\r
+ (q->param_info[p].pdt->get_type_str()).c_str(),\r
+ q->param_info[p].offset\r
+ );\r
+ }\r
+ printf("Min param block size is %d\n\n",q->min_param_size);\r
+\r
+\r
+\r
+}\r
+\r
+\r
Code Review / com / gs-lite.git / blobdiff