src/ftacmp/schemaparser.cc

   1 /* ------------------------------------------------\r
   2 Copyright 2014 AT&T Intellectual Property\r
   3    Licensed under the Apache License, Version 2.0 (the "License");\r
   4    you may not use this file except in compliance with the License.\r
   5    You may obtain a copy of the License at\r
   6 \r
   7      http://www.apache.org/licenses/LICENSE-2.0\r
   8 \r
   9    Unless required by applicable law or agreed to in writing, software\r
  10    distributed under the License is distributed on an "AS IS" BASIS,\r
  11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  12    See the License for the specific language governing permissions and\r
  13    limitations under the License.\r
  14  ------------------------------------------- */\r
  15 \r
  16 #include"schemaparser_impl.h"\r
  17 #include"schemaparser.h"\r
  18 #include <string>\r
  19 #include "parse_fta.h"\r
  20 #include "parse_schema.h"\r
  21 #include"generate_utils.h"\r
  22 \r
  23 #include"host_tuple.h"\r
  24 #include"lapp.h"\r
  25 \r
  26 #include <stdlib.h>\r
  27 #include <stdio.h>\r
  28 #include <string.h>\r
  29 \r
  30 \r
  31 //              Interface to FTA definition lexer and parser ...\r
  32 \r
  33 extern int FtaParserparse(void);\r
  34 extern FILE *FtaParserin;\r
  35 extern int FtaParserdebug;\r
  36 \r
  37 //                      This will need to be moved to a parse_fta.cc file.\r
  38 fta_parse_t *fta_parse_result;\r
  39 var_defs_t *fta_parse_defines;\r
  40 \r
  41 \r
  42 \r
  43 using namespace std;\r
  44 extern int errno;\r
  45 \r
  46 static gs_int8_t tmpstr[20000];                 // for returning const char* values.\r
  47 \r
  48 vector<query_rep *> schema_list;        //      The schemas parsed thus far.\r
  49 \r
  50 /////////////////////////////////////////////////////////////\r
  51 ///                                     Version functions\r
  52 \r
  53 static gs_int32_t curr_version = 4;\r
  54 static gs_int32_t accepted_versions[] = { 4, 3, 2, 1, 0 };              // must end with zero.\r
  55 \r
  56 gs_int32_t get_schemaparser_version(){ return curr_version; }\r
  57 \r
  58 gs_int32_t *get_schemaparser_accepted_versions(){return accepted_versions;}\r
  59 \r
  60 gs_int32_t schemaparser_accepts_version(gs_int32_t v){\r
  61         int i;\r
  62         for(i=0;accepted_versions[i]>0;++i){\r
  63                 if(accepted_versions[i] == v) return 1;\r
  64         }\r
  65         return 0;\r
  66 }\r
  67 \r
  68 \r
  69 /////////////////////////////////////////////////////////////////////\r
  70 ////////////            Utility Functions\r
  71 \r
  72 /*\r
  73 int fta_field_size(int dt, int *is_udef){\r
  74         switch(dt){\r
  75         case INT_TYPE:\r
  76                 return(sizeof(int));\r
  77         case UINT_TYPE:\r
  78         case USHORT_TYPE:\r
  79         case BOOL_TYPE:\r
  80                 return(sizeof(unsigned int));\r
  81         case ULLONG_TYPE:\r
  82                 return(sizeof(unsigned long long int));\r
  83         case LLONG_TYPE:\r
  84                 return(sizeof(long long int));\r
  85         case FLOAT_TYPE:\r
  86                 return(sizeof(double));\r
  87         case TIMEVAL_TYPE:\r
  88                 return(sizeof(timeval));\r
  89         case VSTR_TYPE:\r
  90                 return(sizeof(vstring));\r
  91         default:\r
  92                 *is_udef = 1;\r
  93                 return(0);\r
  94         }\r
  95         return(0);\r
  96 };\r
  97 */\r
  98 \r
  99 \r
 100 /////////////////////////////////////////////////////////////\r
 101 ///                     Interface fcns\r
 102 \r
 103 \r
 104 ////////////            Schema management\r
 105 \r
 106 static gs_schemahandle_t ftaschema_parse(int prot_ok);\r
 107 \r
 108 gs_schemahandle_t ftaschema_parse_string(gs_csp_t f){\r
 109                         // prot_ok is by default false in schemaparser.h\r
 110 \r
 111           fta_parse_result = new fta_parse_t();\r
 112           gs_sp_t schema = strdup(f);\r
 113 \r
 114 //        FtaParserin = f;\r
 115           FtaParser_setstringinput(schema);\r
 116 \r
 117           if(FtaParserparse()){\r
 118                 fprintf(stderr,"FTA parse failed.\n");\r
 119                 free (schema);\r
 120                 return(-1);\r
 121           }\r
 122           free (schema);\r
 123 \r
 124           return ftaschema_parse(false);\r
 125 }\r
 126 gs_schemahandle_t ftaschema_parse_string_prot(gs_csp_t f){\r
 127                         // prot_ok is by default false in schemaparser.h\r
 128 \r
 129           fta_parse_result = new fta_parse_t();\r
 130           gs_sp_t schema = strdup(f);\r
 131 \r
 132 //        FtaParserin = f;\r
 133           FtaParser_setstringinput(schema);\r
 134 \r
 135           if(FtaParserparse()){\r
 136                 fprintf(stderr,"FTA parse failed.\n");\r
 137                 free (schema);\r
 138                 return(-1);\r
 139           }\r
 140           free (schema);\r
 141 \r
 142           return ftaschema_parse(true);\r
 143 }\r
 144 \r
 145 gs_schemahandle_t ftaschema_parse_file(FILE *f){\r
 146                         // prot_ok is by default false in schemaparser.h\r
 147 \r
 148           fta_parse_result = new fta_parse_t();\r
 149 \r
 150 //        FtaParserin = f;\r
 151           FtaParser_setfileinput(f);\r
 152 \r
 153           if(FtaParserparse()){\r
 154                 fprintf(stderr,"FTA parse failed.\n");\r
 155                 return(-1);\r
 156           }\r
 157 \r
 158           return ftaschema_parse(false);\r
 159 }\r
 160 gs_schemahandle_t ftaschema_parse_file_prot(FILE *f){\r
 161                         // prot_ok is by default false in schemaparser.h\r
 162 \r
 163           fta_parse_result = new fta_parse_t();\r
 164 \r
 165 //        FtaParserin = f;\r
 166           FtaParser_setfileinput(f);\r
 167 \r
 168           if(FtaParserparse()){\r
 169                 fprintf(stderr,"FTA parse failed.\n");\r
 170                 return(-1);\r
 171           }\r
 172 \r
 173           return ftaschema_parse(true);\r
 174 }\r
 175 \r
 176 \r
 177 \r
 178 \r
 179 \r
 180 static gs_schemahandle_t ftaschema_parse(int prot_ok){\r
 181 \r
 182         if(fta_parse_result->parse_type != STREAM_PARSE){\r
 183                 if(!(fta_parse_result->parse_type == TABLE_PARSE && prot_ok!=0)){\r
 184                         fprintf(stderr,"ERROR, input is not a stream file.\n");\r
 185                         return(-1);\r
 186                 }\r
 187         }\r
 188 \r
 189 \r
 190 //                      Get the tuple information.\r
 191           if(fta_parse_result->tables->size() != 1){\r
 192                 fprintf(stderr,"ERROR parsing schema file: %d tables, expecting 1.\n",\r
 193                         fta_parse_result->tables->size() );\r
 194                 return(-1);\r
 195           }\r
 196 \r
 197           string table_name = fta_parse_result->tables->get_table_name(0);\r
 198           vector<field_entry *> tuple_flds = fta_parse_result->tables->get_fields(table_name);\r
 199           int n_tuples = tuple_flds.size();\r
 200 \r
 201 //                      get the parameter info.\r
 202           int n_params = 0;\r
 203           string query_name = table_name;\r
 204           vector<var_pair_t *> query_params;\r
 205           if(fta_parse_result->fta_parse_tree){\r
 206                 query_params = fta_parse_result->fta_parse_tree->query_params;\r
 207                 n_params = query_params.size();\r
 208 \r
 209 //                      Get the query name\r
 210                 if(fta_parse_result->fta_parse_tree->nmap.count("query_name") == 0){\r
 211                         fprintf(stderr,"WARNING: query name is empty. using default_query.\n");\r
 212                         query_name = "default_query";\r
 213                 }else{\r
 214                         query_name = fta_parse_result->fta_parse_tree->nmap["query_name"];\r
 215                 }\r
 216 \r
 217                 if(query_name != table_name){\r
 218                         fprintf(stderr,"WARNING table name (%s) is different than query name (%s).\n",\r
 219                                 table_name.c_str(), query_name.c_str() );\r
 220                 }\r
 221 \r
 222           }\r
 223 \r
 224 //                      Construct the query representation.\r
 225 \r
 226           query_rep *qrep = new query_rep(query_name, n_tuples, n_params);\r
 227 \r
 228 //                      Pack the tuple information.\r
 229           int fi;\r
 230           for(fi=0;fi<n_tuples;++fi){\r
 231                 if((qrep->set_field_info(fi,tuple_flds[fi])) == UNDEFINED_TYPE){\r
 232                         fprintf(stderr,"ERROR tuple field %s (number %d) has undefined type %s.\n",\r
 233                                 tuple_flds[fi]->get_name().c_str(), fi, tuple_flds[fi]->get_type().c_str());\r
 234                 }\r
 235           }\r
 236           if(qrep->finalize_field_info()){\r
 237                 fprintf(stderr,"ERROR undefined type in tuple.\n");\r
 238                 return(-1);\r
 239           }\r
 240 \r
 241 //                      Pack the param info\r
 242           int pi;\r
 243           for(pi=0;pi<n_params;++pi){\r
 244                 if((qrep->set_param_info(pi, query_params[pi])) == UNDEFINED_TYPE){\r
 245                         fprintf(stderr,"ERROR parameter %s (number %d) has undefined type %s.\n",\r
 246                                 query_params[pi]->name.c_str(), pi, query_params[pi]->val.c_str());\r
 247                 }\r
 248           }\r
 249           if(qrep->finalize_param_info()){\r
 250                 fprintf(stderr,"ERROR undefined type in parameter block.\n");\r
 251                 return(-1);\r
 252           }\r
 253 \r
 254 //                      finish up\r
 255 \r
 256         schema_list.push_back(qrep);\r
 257 \r
 258         return(schema_list.size()-1);\r
 259 }\r
 260 \r
 261 \r
 262 /*                      Release memory used by the schema representation.\r
 263                         return non-zero on error.\r
 264 */\r
 265 //                      Currently, do nothing.  I'll need to\r
 266 //                      systematically plug memory leaks and write destructors\r
 267 //                      to make implementing this function worth while.\r
 268 gs_int32_t ftaschema_free(gs_schemahandle_t sh){\r
 269         return(0);\r
 270 }\r
 271 \r
 272 \r
 273 /* name of fta schema null terminated */\r
 274 /* Returns NULL if sh is out of bounds. */\r
 275 /* NO ALLOCATION IS PERFORMED!   Must treat result as const. */\r
 276 gs_sp_t ftaschema_name(gs_schemahandle_t sh){\r
 277         if(sh < 0 || sh >= schema_list.size()){\r
 278                 return(NULL);\r
 279         }\r
 280         strcpy(tmpstr,schema_list[sh]->name.c_str());\r
 281         return(tmpstr);\r
 282 }\r
 283 \r
 284 \r
 285 /////////////           Tuple management\r
 286 \r
 287 \r
 288 /* number of entries in a tuple */\r
 289 /* Return -1 if the schema handle is out of range.      */\r
 290 gs_int32_t ftaschema_tuple_len(gs_schemahandle_t sh){\r
 291         if(sh < 0 || sh >= schema_list.size()){\r
 292                 return(-1);\r
 293         }\r
 294         return(schema_list[sh]->field_info.size());\r
 295 }\r
 296 \r
 297 /* field entry name */\r
 298 /* Returns NULL if sh or index is out of bounds.        */\r
 299 /* NO ALLOCATION IS PERFORMED!   Must treat result as const. */\r
 300 gs_sp_t ftaschema_field_name(gs_schemahandle_t sh, gs_uint32_t index){\r
 301         if(sh < 0 || sh >= schema_list.size()){\r
 302                 return(NULL);\r
 303         }\r
 304         if(index >= schema_list[sh]->field_info.size()){\r
 305                 return(NULL);\r
 306         }\r
 307         strcpy(tmpstr,schema_list[sh]->field_info[index].field_name.c_str());\r
 308         return( tmpstr);\r
 309 }\r
 310 \r
 311 /*                      Direct tuple access functions.\r
 312 */\r
 313 gs_uint32_t fta_unpack_uint(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 314         gs_uint32_t retval;\r
 315         if(offset+sizeof(gs_uint32_t) > len){\r
 316                 *problem = 1;\r
 317                 return(0);\r
 318         }\r
 319         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 320 //      return(htonl(retval));\r
 321         return(retval);\r
 322 }\r
 323 gs_uint32_t fta_unpack_uint_nocheck(void *data, gs_uint32_t offset){\r
 324         gs_uint32_t retval;\r
 325         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 326         return(retval);\r
 327 }\r
 328 \r
 329 gs_uint32_t fta_unpack_ushort(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 330         gs_uint32_t retval;\r
 331         if(offset+sizeof(gs_uint32_t) > len){\r
 332                 *problem = 1;\r
 333                 return(0);\r
 334         }\r
 335         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 336 //      return(htonl(retval));\r
 337         return(retval);\r
 338 }\r
 339 gs_uint32_t fta_unpack_ushort_nocheck(void *data, gs_uint32_t offset){\r
 340         gs_uint32_t retval;\r
 341         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 342         return(retval);\r
 343 }\r
 344 \r
 345 gs_uint32_t fta_unpack_bool(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 346         gs_uint32_t retval;\r
 347         if(offset+sizeof(gs_uint32_t) > len){\r
 348                 *problem = 1;\r
 349                 return(0);\r
 350         }\r
 351         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 352 //      return(htonl(retval));\r
 353         return(retval);\r
 354 }\r
 355 gs_uint32_t fta_unpack_bool_nocheck(void *data, gs_uint32_t offset){\r
 356         gs_uint32_t retval;\r
 357         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 358 //      return(htonl(retval));\r
 359         return(retval);\r
 360 }\r
 361 \r
 362 gs_int32_t fta_unpack_int(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 363         gs_int32_t retval;\r
 364         if(offset+sizeof(gs_int32_t) > len){\r
 365                 *problem = 1;\r
 366                 return(0);\r
 367         }\r
 368         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
 369 //      return(htonl(retval));\r
 370         return(retval);\r
 371 }\r
 372 gs_int32_t fta_unpack_int_nocheck(void *data, gs_uint32_t offset){\r
 373         gs_int32_t retval;\r
 374         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
 375         return(retval);\r
 376 }\r
 377 \r
 378 gs_uint64_t fta_unpack_ullong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 379         gs_uint64_t retval;\r
 380         if(offset+sizeof(gs_uint64_t) > len){\r
 381                 *problem = 1;\r
 382                 return(0);\r
 383         }\r
 384         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
 385 //      return(htonll(retval));\r
 386         return(retval);\r
 387 }\r
 388 gs_uint64_t fta_unpack_ullong_nocheck(void *data, gs_uint32_t offset){\r
 389         gs_uint64_t retval;\r
 390         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
 391         return(retval);\r
 392 }\r
 393 \r
 394 gs_int64_t fta_unpack_llong(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 395         gs_int64_t retval;\r
 396         if(offset+sizeof( gs_int64_t) > len){\r
 397                 *problem = 1;\r
 398                 return(0);\r
 399         }\r
 400         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
 401 //      return(htonl(retval));\r
 402         return(retval);\r
 403 }\r
 404 gs_int64_t fta_unpack_llong_nocheck(void *data, gs_uint32_t offset){\r
 405         gs_int64_t retval;\r
 406         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
 407         return(retval);\r
 408 }\r
 409 \r
 410 gs_float_t fta_unpack_float(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 411         gs_float_t retval;\r
 412         if(offset+sizeof( gs_float_t) > len){\r
 413                 *problem = 1;\r
 414                 return(0.0);\r
 415         }\r
 416         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
 417 //      return(ntohf(retval));\r
 418         return(retval);\r
 419 }\r
 420 gs_float_t fta_unpack_float_nocheck(void *data, gs_uint32_t offset){\r
 421         gs_float_t retval;\r
 422         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
 423         return(retval);\r
 424 }\r
 425 \r
 426 timeval fta_unpack_timeval(void *data, gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 427         timeval retval;\r
 428         if(offset+sizeof( timeval) > len){\r
 429                 *problem = 1;\r
 430                 return(retval);\r
 431         }\r
 432         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
 433 //      retval.tv_sec = htonl(retval.tv_sec);\r
 434 //      retval.tv_usec = htonl(retval.tv_usec);\r
 435         retval.tv_sec = retval.tv_sec;\r
 436         retval.tv_usec = retval.tv_usec;\r
 437         return(retval);\r
 438 }\r
 439 timeval fta_unpack_timeval_nocheck(void *data, gs_uint32_t offset){\r
 440         timeval retval;\r
 441         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
 442         retval.tv_sec = retval.tv_sec;\r
 443         retval.tv_usec = retval.tv_usec;\r
 444         return(retval);\r
 445 }\r
 446 \r
 447 vstring fta_unpack_vstr(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 448         vstring retval;\r
 449         vstring32 unpack_s;\r
 450 \r
 451         if(offset+sizeof( vstring32) > len){\r
 452                 *problem = 1;\r
 453                 return(retval);\r
 454         }\r
 455 \r
 456         memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));\r
 457 \r
 458 //      retval.length = htonl(unpack_s.length);\r
 459 //      unpack_s.offset = htonl(unpack_s.offset);\r
 460         retval.length = unpack_s.length;\r
 461         unpack_s.offset = unpack_s.offset;\r
 462         retval.reserved = SHALLOW_COPY;\r
 463 \r
 464         if(unpack_s.offset + retval.length > len){\r
 465                 *problem = 1;\r
 466                 return(retval);\r
 467         }\r
 468         retval.offset = (gs_p_t)data + unpack_s.offset;\r
 469         return(retval);\r
 470 }\r
 471 \r
 472 gs_sp_t fta_unpack_fstring(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 473         return( (gs_sp_t)(data)+offset);\r
 474 }\r
 475 \r
 476 struct hfta_ipv6_str fta_unpack_ipv6(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 477         struct hfta_ipv6_str retval;\r
 478         if(offset+sizeof(hfta_ipv6_str) > len){\r
 479                 *problem = 1;\r
 480                 return(retval);\r
 481         }\r
 482         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
 483 //              htonl(retval.v[0]);\r
 484 //              htonl(retval.v[1]);\r
 485 //              htonl(retval.v[2]);\r
 486 //              htonl(retval.v[3]);\r
 487         return(retval);\r
 488 }\r
 489 struct hfta_ipv6_str fta_unpack_ipv6_nocheck(void *data, gs_uint32_t offset){\r
 490         struct hfta_ipv6_str retval;\r
 491         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
 492         return(retval);\r
 493 }\r
 494 \r
 495 \r
 496 /*\r
 497                 Direct tuple access functions, but no ntoh xform.\r
 498 */\r
 499 gs_uint32_t fta_unpack_uint_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 500         gs_uint32_t retval;\r
 501         if(offset+sizeof(gs_uint32_t) > len){\r
 502                 *problem = 1;\r
 503                 return(0);\r
 504         }\r
 505         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 506         return(retval);\r
 507 }\r
 508 gs_uint32_t fta_unpack_uint_noxf_nocheck(void *data, gs_uint32_t offset){\r
 509         gs_uint32_t retval;\r
 510         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 511         return(retval);\r
 512 }\r
 513 \r
 514 gs_uint32_t fta_unpack_ushort_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 515         gs_uint32_t retval;\r
 516         if(offset+sizeof(gs_uint32_t) > len){\r
 517                 *problem = 1;\r
 518                 return(0);\r
 519         }\r
 520         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 521         return(retval);\r
 522 }\r
 523 gs_uint32_t fta_unpack_ushort_noxf_nocheck(void *data, gs_uint32_t offset){\r
 524         gs_uint32_t retval;\r
 525         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 526         return(retval);\r
 527 }\r
 528 \r
 529 gs_uint32_t fta_unpack_bool_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 530         gs_uint32_t retval;\r
 531         if(offset+sizeof(gs_uint32_t) > len){\r
 532                 *problem = 1;\r
 533                 return(0);\r
 534         }\r
 535         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 536         return(retval);\r
 537 }\r
 538 gs_uint32_t fta_unpack_bool_noxf_nocheck(void *data, gs_uint32_t offset){\r
 539         gs_uint32_t retval;\r
 540         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint32_t));\r
 541         return(retval);\r
 542 }\r
 543 \r
 544 gs_int32_t fta_unpack_int_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 545         gs_int32_t retval;\r
 546         if(offset+sizeof(gs_int32_t) > len){\r
 547                 *problem = 1;\r
 548                 return(0);\r
 549         }\r
 550         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
 551         return(retval);\r
 552 }\r
 553 gs_int32_t fta_unpack_int_noxf_nocheck(void *data, gs_uint32_t offset){\r
 554         gs_int32_t retval;\r
 555         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int32_t));\r
 556         return(retval);\r
 557 }\r
 558 \r
 559 gs_uint64_t fta_unpack_ullong_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 560         gs_int64_t retval;\r
 561         if(offset+sizeof( gs_uint64_t) > len){\r
 562                 *problem = 1;\r
 563                 return(0);\r
 564         }\r
 565         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
 566         return(retval);\r
 567 }\r
 568 gs_uint64_t fta_unpack_ullong_noxf_nocheck(void *data, gs_uint32_t offset){\r
 569         gs_uint64_t retval;\r
 570         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_uint64_t));\r
 571         return(retval);\r
 572 }\r
 573 \r
 574 gs_int64_t fta_unpack_llong_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 575         gs_int64_t retval;\r
 576         if(offset+sizeof( gs_int64_t) > len){\r
 577                 *problem = 1;\r
 578                 return(0);\r
 579         }\r
 580         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
 581         return(retval);\r
 582 }\r
 583 gs_int64_t fta_unpack_llong_noxf_nocheck(void *data, gs_uint32_t offset){\r
 584         gs_int64_t retval;\r
 585         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_int64_t));\r
 586         return(retval);\r
 587 }\r
 588 \r
 589 gs_float_t fta_unpack_float_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 590         gs_float_t retval;\r
 591         if(offset+sizeof( gs_float_t) > len){\r
 592                 *problem = 1;\r
 593                 return(0.0);\r
 594         }\r
 595         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
 596         return(retval);\r
 597 }\r
 598 gs_float_t fta_unpack_float_noxf_nocheck(void *data, gs_uint32_t offset){\r
 599         gs_float_t retval;\r
 600         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(gs_float_t));\r
 601         return(retval);\r
 602 }\r
 603 \r
 604 timeval fta_unpack_timeval_noxf_nocheck(void *data, gs_uint32_t offset){\r
 605         timeval retval;\r
 606         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(timeval));\r
 607         return(retval);\r
 608 }\r
 609 \r
 610 vstring fta_unpack_vstr_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 611         vstring retval;\r
 612         vstring32 unpack_s;\r
 613 \r
 614         if(offset+sizeof( vstring32) > len){\r
 615                 *problem = 1;\r
 616                 return(retval);\r
 617         }\r
 618 \r
 619         memcpy(&unpack_s, ((gs_sp_t)data)+offset, sizeof(vstring32));\r
 620 \r
 621         retval.length = unpack_s.length;\r
 622         retval.reserved = SHALLOW_COPY;\r
 623 \r
 624         if(unpack_s.offset + unpack_s.length > len){\r
 625                 *problem = 1;\r
 626                 return(retval);\r
 627         }\r
 628         retval.offset = (gs_p_t)data + unpack_s.offset;\r
 629         return(retval);\r
 630 }\r
 631 \r
 632 gs_sp_t fta_unpack_fstring_noxf(void *data,  gs_int32_t len, gs_uint32_t offset, gs_int32_t *problem){\r
 633         return( (gs_sp_t)(data)+offset);\r
 634 }\r
 635 \r
 636 struct hfta_ipv6_str fta_unpack_ipv6_noxf_nocheck(void *data, gs_uint32_t offset){\r
 637         struct hfta_ipv6_str retval;\r
 638         memcpy(&retval, ((gs_sp_t)data)+offset, sizeof(hfta_ipv6_str));\r
 639         return(retval);\r
 640 }\r
 641 \r
 642 \r
 643 /* returns fields offset by name        */\r
 644 /* if sh is out of bounds, or if fieldname is not the name of a field,\r
 645    or len is too small,\r
 646    return value is -1\r
 647 */\r
 648 gs_int32_t ftaschema_get_field_offset_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){\r
 649         if(sh < 0 || sh >= schema_list.size()){\r
 650                         return(-1);\r
 651         }\r
 652 \r
 653         int f;\r
 654         for(f=0;f<schema_list[sh]->field_info.size();++f){\r
 655                 if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
 656                         return(schema_list[sh]->field_info[f].offset);\r
 657         }\r
 658 \r
 659 //              Nothing found\r
 660         return(-1);\r
 661 \r
 662 }\r
 663 /* field offset by index, return -1 if sh or idx is out-of-bounds */\r
 664 gs_int32_t ftaschema_get_field_offset_by_index(gs_schemahandle_t sh, gs_int32_t idx){\r
 665         if(sh < 0 || sh >= schema_list.size()){\r
 666                         return(-1);\r
 667         }\r
 668         if(idx < 0 || idx >= schema_list[sh]->field_info.size()){\r
 669                         return(-1);\r
 670         }\r
 671 \r
 672         return(schema_list[sh]->field_info[idx].offset);\r
 673 \r
 674 }\r
 675 \r
 676 \r
 677 /* returns fields type by name  */\r
 678 /* if sh is out of bounds, or if fieldname is not the name of a field,\r
 679    or len is too small,\r
 680    return value is UNDEFINED_TYPE\r
 681 */\r
 682 gs_int32_t ftaschema_get_field_type_by_name(gs_schemahandle_t sh, gs_csp_t fieldname){\r
 683         if(sh < 0 || sh >= schema_list.size()){\r
 684                         return(UNDEFINED_TYPE);\r
 685         }\r
 686 \r
 687         int f;\r
 688         for(f=0;f<schema_list[sh]->field_info.size();++f){\r
 689                 if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
 690                 return(schema_list[sh]->field_info[f].pdt->type_indicator());\r
 691         }\r
 692 \r
 693 //              Nothing found\r
 694         return( UNDEFINED_TYPE);\r
 695 }\r
 696 /* field type by index, rteturn value is UNDEFINED_TYPE if sh or idx \r
 697  * is out of bounds\r
 698 */\r
 699 gs_int32_t ftaschema_get_field_type_by_index(gs_schemahandle_t sh, gs_int32_t idx){\r
 700         if(sh < 0 || sh >= schema_list.size()){\r
 701                         return(UNDEFINED_TYPE);\r
 702         }\r
 703         if(idx < 0 || idx >= schema_list[sh]->field_info.size()){\r
 704                         return(UNDEFINED_TYPE);\r
 705         }\r
 706 \r
 707         return(schema_list[sh]->field_info[idx].pdt->type_indicator());\r
 708 }\r
 709 \r
 710 \r
 711 /* returns tuple value based on name */\r
 712 /* if sh is out of bounds, or if fieldname is not the name of a field,\r
 713    or len is too small,\r
 714    return value is of type UNDEFINED_TYPE\r
 715 */\r
 716 access_result ftaschema_get_field_by_name(gs_schemahandle_t sh, gs_csp_t fieldname,\r
 717                                           void * data, gs_uint32_t len){\r
 718         access_result retval;\r
 719         retval.field_data_type = UNDEFINED_TYPE;\r
 720 \r
 721         if(sh < 0 || sh >= schema_list.size()){\r
 722                         return(retval);\r
 723         }\r
 724 \r
 725         int f;\r
 726         for(f=0;f<schema_list[sh]->field_info.size();++f){\r
 727                 if(strcmp(fieldname, schema_list[sh]->field_info[f].field_name.c_str()) == 0)\r
 728                         return(ftaschema_get_field_by_index(sh,f,data,len));\r
 729         }\r
 730 \r
 731 //              Nothing found\r
 732         return(retval);\r
 733 \r
 734 }\r
 735 \r
 736 /* return tuple value by index */\r
 737 /* if sh is out of bounds, or if fieldname is not the name of a field,\r
 738    or len is too small,\r
 739    return value is of type UNDEFINED_TYPE\r
 740 */\r
 741 access_result ftaschema_get_field_by_index(gs_schemahandle_t sh, gs_uint32_t index,\r
 742                                           void * data, gs_uint32_t len){\r
 743         access_result retval;\r
 744         retval.field_data_type = UNDEFINED_TYPE;\r
 745         gs_int32_t problem = 0;\r
 746 \r
 747         if(sh < 0 || sh >= schema_list.size()){\r
 748                         return(retval);\r
 749         }\r
 750         if(index >= schema_list[sh]->field_info.size()){\r
 751                 return(retval);\r
 752         }\r
 753 \r
 754         switch(schema_list[sh]->field_info[index].pdt->get_type()){\r
 755         case u_int_t:\r
 756                 retval.r.ui = fta_unpack_uint(data,  len,\r
 757                         schema_list[sh]->field_info[index].offset, &problem);\r
 758                 if(!problem) retval.field_data_type = UINT_TYPE;\r
 759                 break;\r
 760         case ip_t:\r
 761                 retval.r.ui = fta_unpack_uint(data,  len,\r
 762                         schema_list[sh]->field_info[index].offset, &problem);\r
 763                 if(!problem) retval.field_data_type = IP_TYPE;\r
 764                 break;\r
 765         case int_t:\r
 766                 retval.r.i = fta_unpack_int(data,  len,\r
 767                         schema_list[sh]->field_info[index].offset, &problem);\r
 768                 if(!problem) retval.field_data_type = INT_TYPE;\r
 769                 break;\r
 770         case u_llong_t:\r
 771                 retval.r.ul = fta_unpack_ullong(data,  len,\r
 772                         schema_list[sh]->field_info[index].offset, &problem);\r
 773                 if(!problem) retval.field_data_type = ULLONG_TYPE;\r
 774                 break;\r
 775         case llong_t:\r
 776                 retval.r.l = fta_unpack_llong(data,  len,\r
 777                         schema_list[sh]->field_info[index].offset, &problem);\r
 778                 if(!problem) retval.field_data_type = LLONG_TYPE;\r
 779                 break;\r
 780         case u_short_t:\r
 781                 retval.r.ui = fta_unpack_ushort(data,  len,\r
 782                         schema_list[sh]->field_info[index].offset, &problem);\r
 783                 if(!problem) retval.field_data_type = USHORT_TYPE;\r
 784                 break;\r
 785         case floating_t:\r
 786                 retval.r.f = fta_unpack_float(data,  len,\r
 787                         schema_list[sh]->field_info[index].offset, &problem);\r
 788                 if(!problem) retval.field_data_type = FLOAT_TYPE;\r
 789                 break;\r
 790         case bool_t:\r
 791                 retval.r.ui = fta_unpack_bool(data,  len,\r
 792                         schema_list[sh]->field_info[index].offset, &problem);\r
 793                 if(!problem) retval.field_data_type = BOOL_TYPE;\r
 794                 break;\r
 795         case v_str_t:\r
 796                 retval.r.vs = fta_unpack_vstr(data,  len,\r
 797                         schema_list[sh]->field_info[index].offset, &problem);\r
 798                 if(!problem) retval.field_data_type = VSTR_TYPE;\r
 799                 break;\r
 800         case fstring_t:\r
 801                 retval.r.fs.data = fta_unpack_fstring(data,  len,\r
 802                         schema_list[sh]->field_info[index].offset, &problem);\r
 803                 retval.r.fs.size = schema_list[sh]->field_info[index].pdt->type_size();\r
 804                 if(!problem) retval.field_data_type = FSTRING_TYPE;\r
 805         case timeval_t:\r
 806                 retval.r.t = fta_unpack_timeval(data,  len,\r
 807                         schema_list[sh]->field_info[index].offset, &problem);\r
 808                 if(!problem) retval.field_data_type = TIMEVAL_TYPE;\r
 809                 break;\r
 810         case ipv6_t:\r
 811                 retval.r.ip6 = fta_unpack_ipv6(data,  len,\r
 812                         schema_list[sh]->field_info[index].offset, &problem);\r
 813                 if(!problem) retval.field_data_type = IPV6_TYPE;\r
 814                 break;\r
 815         case undefined_t:\r
 816                 break;\r
 817         }\r
 818         return(retval);\r
 819 }\r
 820 \r
 821 \r
 822 //              Get location of eof, temporal-tuple metadata.\r
 823 gs_int32_t ftaschema_get_tuple_metadata_offset(gs_schemahandle_t sh){\r
 824         if(sh < 0 || sh >= schema_list.size())\r
 825                 return 0;               // probably need to return a error instead of just telling its not eof tuple\r
 826 \r
 827         return ( schema_list[sh]->min_tuple_size);\r
 828 }\r
 829 \r
 830 \r
 831 /* checks whether tuple is temporal\r
 832   return value 1 indicates that tuple istemporal, 0 - not temporal\r
 833 */\r
 834 gs_int32_t ftaschema_is_temporal_tuple(gs_schemahandle_t sh, void *data) {\r
 835 \r
 836         if(sh < 0 || sh >= schema_list.size())\r
 837                 return 0;               // probably need to return a error instead of just telling its not temporal\r
 838 \r
 839         return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == TEMPORAL_TUPLE);\r
 840 }\r
 841 //inline gs_int32_t ftaschema_is_temporal_tuple_offset(int metadata_offset, void *data) {\r
 842 //      return (*((gs_sp_t)data + metadata_offset) == TEMPORAL_TUPLE);\r
 843 //}\r
 844 \r
 845 \r
 846 \r
 847 /* checks whether tuple is special end-of_file tuple\r
 848   return value 1 indicates that tuple is eof_tuple, 0 - otherwise\r
 849 */\r
 850 gs_int32_t ftaschema_is_eof_tuple(gs_schemahandle_t sh, void *data) {\r
 851         if(sh < 0 || sh >= schema_list.size())\r
 852                 return 0;               // probably need to return a error instead of just telling its not eof tuple\r
 853 \r
 854         return (*((gs_sp_t)data + schema_list[sh]->min_tuple_size) == EOF_TUPLE);\r
 855 \r
 856 }\r
 857 inline gs_int32_t ftaschema_is_eof_tuple_offset(int metadata_offset, void *data) {\r
 858         return (*((gs_sp_t)data + metadata_offset) == EOF_TUPLE);\r
 859 }\r
 860 \r
 861 \r
 862 /* extracts the trace from the temporal tuple\r
 863   return value 0 indicates success, non-zero - error\r
 864 */\r
 865 gs_int32_t ftaschema_get_trace(gs_schemahandle_t sh, void* data, gs_int32_t len,\r
 866         gs_uint64_t* trace_id, gs_uint32_t* sz, fta_stat** trace ) {\r
 867 \r
 868         if(sh < 0 || sh >= schema_list.size() || *((gs_sp_t)data + schema_list[sh]->min_tuple_size) != TEMPORAL_TUPLE)\r
 869                 return 1;\r
 870 \r
 871         memcpy(trace_id, (gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t), sizeof(gs_uint64_t));\r
 872         *trace = (fta_stat*)((gs_sp_t)data + schema_list[sh]->min_tuple_size + sizeof(gs_int8_t) + sizeof(gs_uint64_t));\r
 873         *sz = (len - schema_list[sh]->min_tuple_size - sizeof(gs_int8_t)- sizeof(gs_uint64_t)) / sizeof(fta_stat);\r
 874 \r
 875         return 0;\r
 876 }\r
 877 \r
 878 \r
 879 ////////////    Param block management\r
 880 \r
 881 /* number of parameters */\r
 882 /*      Return -1 if sh is out of bounds        */\r
 883 gs_int32_t ftaschema_parameter_len(gs_schemahandle_t sh){\r
 884         if(sh < 0 || sh >= schema_list.size()){\r
 885                 return(-1);\r
 886         }\r
 887         return(schema_list[sh]->param_info.size());\r
 888 }\r
 889 \r
 890 /* parameter entry name */\r
 891 /*      Return NULL if sh or index is out of bounds.    */\r
 892 /*      NO COPYING IS PERFORMED */\r
 893 gs_sp_t ftaschema_parameter_name(gs_schemahandle_t sh, gs_uint32_t index){\r
 894         if(sh < 0 || sh >= schema_list.size()){\r
 895                 return(NULL);\r
 896         }\r
 897     if(index >= schema_list[sh]->param_info.size()){\r
 898         return(NULL);\r
 899     }\r
 900         strcpy(tmpstr,schema_list[sh]->param_info[index].param_name.c_str());\r
 901     return(tmpstr);\r
 902 }\r
 903 \r
 904 /* set parameter value for parameter handle */\r
 905 /*      Pass in the parameter in its char string representation. */\r
 906 /*  Return value is -1 on error, else 0 */\r
 907 gs_int32_t ftaschema_setparam_by_name(gs_schemahandle_t sh, gs_sp_t param_name,\r
 908                                gs_sp_t param_val, gs_int32_t len){\r
 909         if(sh < 0 || sh >= schema_list.size()){\r
 910                         return(-1);\r
 911         }\r
 912 \r
 913         int f;\r
 914         for(f=0;f<schema_list[sh]->param_info.size();++f){\r
 915                 if(strcmp(param_name, schema_list[sh]->param_info[f].param_name.c_str()) == 0)\r
 916                         return(ftaschema_setparam_by_index(sh,f,param_val,len));\r
 917         }\r
 918 \r
 919 //              not found\r
 920         return(-1);\r
 921 }\r
 922 \r
 923 /* set parameter value for parameter handle */\r
 924 /*      Pass in the parameter in its char string representation. */\r
 925 /*  Return value is -1 on error, else 0 */\r
 926 gs_int32_t ftaschema_setparam_by_index(gs_schemahandle_t sh, gs_int32_t index,\r
 927                                 gs_sp_t param_val, gs_int32_t len){\r
 928 \r
 929     void *tmp_ptr;\r
 930         unsigned int ui,d1,d2,d3,d4;\r
 931         int i;\r
 932         unsigned long long int ulli;\r
 933         long long int lli;\r
 934         double f;\r
 935 \r
 936 \r
 937         if(sh < 0 || sh >= schema_list.size()){\r
 938                 return(-1);\r
 939         }\r
 940     if(index >= schema_list[sh]->param_info.size()){\r
 941         return(-1);\r
 942     }\r
 943 \r
 944     param_block_info *pb = &(schema_list[sh]->param_info[index]);\r
 945         switch(pb->pdt->get_type()){\r
 946                 case int_t:\r
 947                         if(sscanf(param_val,"%d",&i) == 1){\r
 948                                 pb->value.r.i=i;\r
 949                                 pb->value_set = true;\r
 950                                 return(0);\r
 951                         }else\r
 952                                 return(-1);\r
 953                         break;\r
 954                 case u_int_t:\r
 955                 case u_short_t:\r
 956                 case bool_t:\r
 957                         if(sscanf(param_val,"%u",&ui) == 1){\r
 958                                 pb->value.r.ui=ui;\r
 959                                 pb->value_set = true;\r
 960                                 return(0);\r
 961                         }else\r
 962                                 return(-1);\r
 963                         break;\r
 964                 case ip_t:\r
 965                         if(sscanf(param_val,"%d.%d.%d.%d",&d1,&d2,&d3,&d4) == 4){\r
 966                                 pb->value.r.ui = (d1 << 24)+(d2 << 16)+(d3 << 8)+d4;\r
 967                                 pb->value_set = true;\r
 968                                 return(0);\r
 969                         }else\r
 970                                 return(-1);\r
 971                 case u_llong_t:\r
 972                         if(sscanf(param_val,"%llu",&ulli) == 1){\r
 973                                 pb->value.r.ul=ulli;\r
 974                                 pb->value_set = true;\r
 975                                 return(0);\r
 976                         }else\r
 977                                 return(-1);\r
 978                         break;\r
 979                 case llong_t:\r
 980                         if(sscanf(param_val,"%lld",&lli) == 1){\r
 981                                 pb->value.r.l=lli;\r
 982                                 pb->value_set = true;\r
 983                                 return(0);\r
 984                         }else\r
 985                                 return(-1);\r
 986                         break;\r
 987                 case floating_t:\r
 988                         if(sscanf(param_val,"%lf",&f) == 1){\r
 989                                 pb->value.r.f=f;\r
 990                                 pb->value_set = true;\r
 991                                 return(0);\r
 992                         }else\r
 993                                 return(-1);\r
 994                         break;\r
 995                 case timeval_t:\r
 996                         if(sscanf(param_val,"(%d,%d)",&d1, &d2) == 2){\r
 997                                 pb->value.r.t.tv_sec = d1;\r
 998                                 pb->value.r.t.tv_usec = d2;\r
 999                                 pb->value_set = true;\r
1000                                 return(0);\r
1001                         }else\r
1002                                 return(-1);\r
1003                         break;\r
1004                 case v_str_t:\r
1005                         if(pb->value.r.vs.offset != 0){\r
1006                                 tmp_ptr = (void *)(pb->value.r.vs.offset);\r
1007                                 free(tmp_ptr);\r
1008                         }\r
1009                         tmp_ptr = malloc(len);\r
1010                         pb->value.r.vs.offset = (gs_p_t)tmp_ptr;\r
1011                         memcpy(tmp_ptr,param_val, len);\r
1012                         pb->value.r.vs.length = len;\r
1013 //                      pb->value.r.vs.reserved = 0;\r
1014                         pb->value.r.vs.reserved = INTERNAL;\r
1015                         pb->value_set = true;\r
1016                         return(0);\r
1017                         break;\r
1018                 case fstring_t:\r
1019                         fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
1020                         exit(1);\r
1021                         break;\r
1022                 case ipv6_t:\r
1023                         fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");\r
1024                         exit(1);\r
1025                         break;\r
1026                 case undefined_t:\r
1027                         fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");\r
1028                         exit(1);\r
1029                 default:\r
1030                         fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_setparam_by_index\n");\r
1031                         exit(1);\r
1032         }\r
1033 \r
1034         return(-1);\r
1035 }\r
1036 \r
1037 gs_int32_t ftaschema_create_param_block(gs_schemahandle_t sh, void ** block, gs_int32_t * size){\r
1038         if(sh < 0 || sh >= schema_list.size()){\r
1039                 return(-1);\r
1040         }\r
1041 \r
1042         *size = schema_list[sh]->min_param_size;\r
1043         int p;\r
1044 \r
1045         for(p=0;p<schema_list[sh]->param_info.size();++p){\r
1046                 if(! schema_list[sh]->param_info[p].value_set) return 1;\r
1047 \r
1048                 switch(schema_list[sh]->param_info[p].pdt->get_type()){\r
1049                 case v_str_t:\r
1050                         *size += schema_list[sh]->param_info[p].value.r.vs.length;\r
1051                         break;\r
1052                 case fstring_t:\r
1053                         fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
1054                         exit(1);\r
1055                         break;\r
1056                 case undefined_t:\r
1057                         return(-1);\r
1058                         break;\r
1059                 default:\r
1060                         break;\r
1061                 }\r
1062         }\r
1063 \r
1064         *block = malloc(*size);\r
1065         if(*block == NULL) return(-1);\r
1066 \r
1067         int data_pos = schema_list[sh]->min_param_size;\r
1068 \r
1069         gs_int32_t tmp_int;\r
1070         gs_uint32_t tmp_uint;\r
1071         gs_int64_t tmp_ll;\r
1072         gs_uint64_t tmp_ull;\r
1073         gs_float_t tmp_f;\r
1074         timeval tmp_tv;\r
1075         vstring32 tmp_vstr;\r
1076         void *tmp_ptr;\r
1077 \r
1078         for(p=0;p<schema_list[sh]->param_info.size();++p){\r
1079                 param_block_info *pb = &(schema_list[sh]->param_info[p]);\r
1080                 switch(pb->pdt->get_type()){\r
1081                         case int_t:\r
1082 //                              tmp_int = htonl(pb->value.r.i);\r
1083                                 tmp_int = pb->value.r.i;\r
1084                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_int,sizeof(gs_int32_t));\r
1085                                 break;\r
1086                         case u_int_t:\r
1087                         case u_short_t:\r
1088                         case bool_t:\r
1089                         case ip_t:\r
1090 //                              tmp_uint = htonl(pb->value.r.ui);\r
1091                                 tmp_uint = pb->value.r.ui;\r
1092                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_uint,sizeof(gs_uint32_t));\r
1093                                 break;\r
1094                         case u_llong_t:\r
1095 //                              tmp_ull = htonll(pb->value.r.ul);\r
1096                                 tmp_ull = pb->value.r.ul;\r
1097                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ull,sizeof(gs_uint64_t));\r
1098                                 break;\r
1099                         case llong_t:\r
1100 //                              tmp_ll = htonll(pb->value.r.l);\r
1101                                 tmp_ll = pb->value.r.l;\r
1102                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_ll,sizeof(gs_int64_t));\r
1103                                 break;\r
1104                         case floating_t:\r
1105 //                              tmp_f = ntohf(pb->value.r.f);\r
1106                                 tmp_f = pb->value.r.f;\r
1107                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_f,sizeof(gs_float_t));\r
1108                                 break;\r
1109                         case timeval_t:\r
1110 //                              tmp_tv.tv_sec = htonl(pb->value.r.t.tv_sec);\r
1111 //                              tmp_tv.tv_usec = htonl(pb->value.r.t.tv_usec);\r
1112                                 tmp_tv.tv_sec = pb->value.r.t.tv_sec;\r
1113                                 tmp_tv.tv_usec =pb->value.r.t.tv_usec;\r
1114                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_tv,sizeof(timeval));\r
1115                                 break;\r
1116                         case v_str_t:\r
1117 //                              tmp_vstr.offset = htonl(data_pos);\r
1118 //                              tmp_vstr.length = htonl(pb->value.r.vs.length);\r
1119                                 tmp_vstr.offset = data_pos;\r
1120                                 tmp_vstr.length = pb->value.r.vs.length;\r
1121 //                              tmp_vstr.reserved = htonl(pb->value.r.vs.reserved);\r
1122 //                              tmp_vstr.reserved = htonl(PACKED);\r
1123                                 tmp_vstr.reserved = PACKED;\r
1124                                 memcpy(((gs_sp_t)(*block))+pb->offset,&tmp_vstr,sizeof(vstring32));\r
1125                                 tmp_ptr = (void *)(pb->value.r.vs.offset);\r
1126                                 memcpy(((gs_sp_t)(*block))+data_pos, tmp_ptr, pb->value.r.vs.length);\r
1127                                 data_pos += pb->value.r.vs.length;\r
1128                                 break;\r
1129                 case fstring_t:\r
1130                         fprintf(stderr,"ERROR, fstring parameters not supported, use vstring.\n");\r
1131                         exit(1);\r
1132                         break;\r
1133                 case ipv6_t:\r
1134                         fprintf(stderr,"ERROR, ipv6_t parameters not supported.\n");\r
1135                         exit(1);\r
1136                         break;\r
1137                 case undefined_t:\r
1138                         fprintf(stderr,"INTERNAL ERROR undefined_t type in ftaschema_setparam_by_index\n");\r
1139                         exit(1);\r
1140                 default:\r
1141                         fprintf(stderr,"INTERNAL ERROR unknown type in ftaschema_create_param_block\n");\r
1142                         exit(1);\r
1143                 }\r
1144         }\r
1145         return(0);\r
1146 \r
1147 }\r
1148 \r
1149 \r
1150 ///////////////////////////////////////////////////////////////\r
1151 //              Diagnostic functions\r
1152 \r
1153 void ftaschema_debugdump(gs_int32_t handle){\r
1154         if(handle<0){\r
1155                 printf("ftaschema_debugdump: handle is negative.\n");\r
1156                 return;\r
1157         }\r
1158         if(handle >= schema_list.size()){\r
1159                 printf("ftaschema_debugdump: handle out of bounds (%d, max is %lu)\n",\r
1160                                 handle, schema_list.size());\r
1161         }\r
1162 \r
1163         query_rep *q = schema_list[handle];\r
1164 \r
1165         printf("Handle is %d, query name is <%s>\n",handle,q->name.c_str());\r
1166         printf("Output tuple has %lu fields:\n",q->field_info.size());\r
1167         int f;\r
1168         for(f=0;f<q->field_info.size();++f){\r
1169                 printf("\t%s (%s) : %d\n",q->field_info[f].field_name.c_str(),\r
1170                         (q->field_info[f].pdt->get_type_str()).c_str(),\r
1171                         q->field_info[f].offset\r
1172                         );\r
1173         }\r
1174         printf("Min tuple size is %d\n\n",q->min_tuple_size);\r
1175         printf("Param block is:\n");\r
1176         int p;\r
1177         for(p=0;p<q->param_info.size();++p){\r
1178                 printf("\t%s (%s) : %d\n",q->param_info[p].param_name.c_str(),\r
1179                         (q->param_info[p].pdt->get_type_str()).c_str(),\r
1180                         q->param_info[p].offset\r
1181                         );\r
1182         }\r
1183         printf("Min param block size is %d\n\n",q->min_param_size);\r
1184 \r
1185 \r
1186 \r
1187 }\r
1188 \r
1189 \r