src/gras/DataDesc/type_driver_rl.c

   1 /* gs_rl_type_driver.c */
   2
   3 #include "DataDesc/gs_private.h"
   4
   5 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(NDR_tdriver_rl,NDR);
   6 /*
   7  * structs
   8  */
   9 struct s_gs_rl_type_driver {
  10         /**/
  11         int dummy;
  12 };
  13
  14 struct s_gs_rl_type_bag {
  15         gras_dict_t             *incoming_dict;
  16
  17         gras_dynar_t            *type_dynar;
  18         gras_dict_t             *type_dict;
  19
  20         gras_dynar_t            *message_dynar;
  21         gras_dict_t             *message_dict;
  22
  23         gras_dict_t             *outgoing_dict;
  24 };
  25
  26 struct s_gs_rl_incoming_connection {
  27         struct s_gs_connection  *p_connection;
  28
  29         gras_dynar_t            *type_dynar;
  30         gras_dict_t             *type_dict;
  31
  32         gras_dynar_t            *message_dynar;
  33         gras_dict_t             *message_dict;
  34 };
  35
  36 struct s_gs_rl_outgoing_connection {
  37         struct s_gs_connection  *p_connection;
  38         gras_dict_t             *type_marker_dict;
  39         gras_dict_t             *message_marker_dict;
  40 };
  41
  42
  43 /*
  44  * static vars
  45  */
  46 static
  47 struct s_gs_type_driver_ops *type_driver_ops = NULL;
  48
  49 static
  50 struct s_gs_type_bag_ops    *type_bag_ops    = NULL;
  51
  52 /*
  53  * exported functions, driver part
  54  */
  55 struct s_gs_type_driver_ops *
  56 gs_rl_type_driver(void) {
  57
  58         if (!type_bag_ops) {
  59                 type_bag_ops    = calloc(1, sizeof(struct s_gs_type_bag_ops));
  60
  61
  62                 type_bag_ops->_init                             = gs_rl_bag__init;
  63                 type_bag_ops->_exit                             = gs_rl_bag__exit;
  64
  65
  66                 type_bag_ops->register_incoming_connection      = gs_rl_bag_register_incoming_connection;
  67                 type_bag_ops->register_outgoing_connection      = gs_rl_bag_register_outgoing_connection;
  68
  69
  70                 type_bag_ops->store_type                        = gs_rl_bag_store_type;
  71                 type_bag_ops->store_incoming_type               = gs_rl_bag_store_incoming_type;
  72                 type_bag_ops->get_type_by_name                  = gs_rl_bag_get_type_by_name;
  73                 type_bag_ops->get_type_by_code                  = gs_rl_bag_get_type_by_code;
  74                 type_bag_ops->mark_type                         = gs_rl_bag_mark_type;
  75                 type_bag_ops->check_type_mark                   = gs_rl_bag_check_type_mark;
  76
  77
  78                 type_bag_ops->store_message                     = gs_rl_bag_store_message;
  79                 type_bag_ops->store_incoming_message            = gs_rl_bag_store_incoming_message;
  80                 type_bag_ops->get_message_by_name               = gs_rl_bag_get_message_by_name;
  81                 type_bag_ops->get_message_by_code               = gs_rl_bag_get_message_by_code;
  82                 type_bag_ops->mark_message                      = gs_rl_bag_mark_message;
  83                 type_bag_ops->check_message_mark                = gs_rl_bag_check_message_mark;
  84         }
  85
  86         if (!type_driver_ops) {
  87                 type_driver_ops = calloc(1, sizeof(struct s_gs_type_driver_ops));
  88
  89                 type_driver_ops->_init  = gs_rl__init;
  90                 type_driver_ops->_exit  = gs_rl__exit;
  91         }
  92
  93         return type_driver_ops;
  94 }
  95
  96 void
  97 gs_rl__init(struct s_gs_type_driver     *p_driver) {
  98
  99         struct s_gs_rl_type_driver *p_rl = NULL;
 100
 101         p_rl = calloc(1, sizeof(struct s_gs_rl_type_driver));
 102         p_driver->specific      = p_rl;
 103         p_driver->bag_ops       = type_bag_ops;
 104 }
 105
 106 void
 107 gs_rl__exit(struct s_gs_type_driver     *p_driver) {
 108
 109         struct s_gs_rl_type_driver *p_rl = p_driver->specific;
 110
 111         free(p_rl);
 112         p_driver->specific = NULL;
 113 }
 114
 115 /*
 116  * exported functions, bag part
 117  */
 118
 119 /* management */
 120 void
 121 gs_rl_bag__init(struct s_gs_type_bag    *p_bag) {
 122
 123         struct s_gs_rl_type_bag *p_rl = NULL;
 124
 125         p_rl = calloc(1, sizeof(struct s_gs_rl_type_bag));
 126
 127         gras_dict_new(&p_rl->incoming_dict);
 128
 129         gras_dynar_new(&p_rl->type_dynar, sizeof(struct s_gs_type *), NULL);
 130         gras_dict_new (&p_rl->type_dict);
 131
 132         gras_dynar_new(&p_rl->message_dynar, sizeof(struct s_gs_type *), NULL);
 133         gras_dict_new (&p_rl->message_dict);
 134
 135         gras_dict_new (&p_rl->outgoing_dict);
 136
 137         p_bag->specific         = p_rl;
 138         p_bag->bag_ops          = type_bag_ops;
 139
 140         gs_bootstrap_type_bag(p_bag);
 141 }
 142
 143 void
 144 gs_rl_bag__exit(struct s_gs_type_bag    *p_bag) {
 145
 146         struct s_gs_rl_type_bag *p_rl = p_bag->specific;
 147
 148         gras_dict_free(&p_rl->type_dict);
 149         gras_dynar_free(p_rl->type_dynar);
 150
 151         free(p_rl);
 152         p_bag->specific = NULL;
 153 }
 154
 155 /* connection */
 156 void
 157 gs_rl_bag_register_incoming_connection(struct s_gs_type_bag     *p_bag,
 158                                        struct s_gs_connection   *p_cnx) {
 159
 160         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 161         struct s_gs_rl_incoming_connection      *p_in   = NULL;
 162
 163         if (p_cnx->direction != e_gs_connection_direction_incoming)
 164                 GS_FAILURE("invalid operation");
 165
 166         p_in = malloc(sizeof (struct s_gs_rl_incoming_connection));
 167
 168         p_in->p_connection      = p_cnx;
 169
 170         gras_dynar_new(&p_in->type_dynar, sizeof(struct s_gs_type *), NULL);
 171         gras_dict_new (&p_in->type_dict);
 172
 173         gras_dynar_new(&p_in->message_dynar, sizeof(struct s_gs_type *), NULL);
 174         gras_dict_new (&p_in->message_dict);
 175
 176         gras_dict_insert_ext(p_rl->incoming_dict,
 177                              (char *)&p_cnx,
 178                              sizeof(p_cnx),
 179                              p_in,
 180                              NULL);
 181
 182         gs_bootstrap_incoming_connection(p_bag, p_cnx);
 183 }
 184
 185
 186 void
 187 gs_rl_bag_register_outgoing_connection(struct s_gs_type_bag     *p_bag,
 188                                        struct s_gs_connection   *p_cnx) {
 189
 190         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 191         struct s_gs_rl_outgoing_connection      *p_out  = NULL;
 192
 193         if (p_cnx->direction != e_gs_connection_direction_outgoing)
 194                 GS_FAILURE("invalid operation");
 195
 196         p_out = malloc(sizeof (struct s_gs_rl_outgoing_connection));
 197
 198         p_out->p_connection     = p_cnx;
 199         gras_dict_new(&p_out->type_marker_dict);
 200         gras_dict_new(&p_out->message_marker_dict);
 201
 202         gras_dict_insert_ext(p_rl->outgoing_dict, (char *)&p_cnx, sizeof(p_cnx), p_out, NULL);
 203
 204         gs_bootstrap_outgoing_connection(p_bag, p_cnx);
 205 }
 206
 207
 208 /* types */
 209 void
 210 gs_rl_bag_store_type(struct s_gs_type_bag       *p_bag,
 211                      struct s_gs_connection     *p_cnx,
 212                      struct s_gs_type           *p_type) {
 213
 214         struct s_gs_rl_type_bag  *p_rl          = p_bag->specific;
 215         struct s_gs_type        **pp_type       = NULL;
 216
 217         pp_type  = malloc(sizeof(struct s_gs_type *));
 218         *pp_type = p_type;
 219
 220         if (p_cnx) {
 221                 struct s_gs_rl_incoming_connection      *p_in   = NULL;
 222
 223                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 224                         GS_FAILURE("invalid operation");
 225
 226                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 227                                        (char *)&p_cnx,
 228                                        sizeof(p_cnx),
 229                                        (void **)&p_in);
 230
 231
 232                 p_type->code = gras_dynar_length(p_in->type_dynar);
 233                 gras_dynar_insert_at(p_in->type_dynar, p_type->code, pp_type);
 234                 gras_dict_insert(p_in->type_dict, p_type->name, pp_type, NULL);
 235         } else {
 236                 p_type->code = gras_dynar_length(p_rl->type_dynar);
 237                 gras_dynar_insert_at(p_rl->type_dynar, p_type->code, pp_type);
 238                 gras_dict_insert(p_rl->type_dict, p_type->name, pp_type, NULL);
 239         }
 240 }
 241
 242 void
 243 gs_rl_bag_store_incoming_type(struct s_gs_type_bag      *p_bag,
 244                               struct s_gs_connection    *p_cnx,
 245                               struct s_gs_type          *p_type) {
 246
 247         struct s_gs_rl_type_bag                  *p_rl          = p_bag->specific;
 248         struct s_gs_rl_incoming_connection       *p_in          = NULL;
 249         struct s_gs_type                        **pp_type       = NULL;
 250
 251         if (p_cnx->direction != e_gs_connection_direction_incoming)
 252                 GS_FAILURE("invalid operation");
 253
 254         gras_dict_retrieve_ext(p_rl->incoming_dict,
 255                                (char *)&p_cnx,
 256                                sizeof(p_cnx),
 257                                (void **)&p_in);
 258
 259         pp_type  = malloc(sizeof(struct s_gs_type *));
 260         *pp_type = p_type;
 261
 262         gras_dynar_set(p_in->type_dynar, p_type->code, pp_type);
 263         gras_dict_insert(p_in->type_dict, p_type->name, pp_type, NULL);
 264 }
 265
 266 struct s_gs_type *
 267 gs_rl_bag_get_type_by_name(struct s_gs_type_bag         *p_bag,
 268                            struct s_gs_connection       *p_cnx,
 269                            const char                   *name) {
 270
 271         struct s_gs_rl_type_bag  *p_rl          = p_bag->specific;
 272         struct s_gs_type        **pp_type       = NULL;
 273
 274         if (p_cnx) {
 275                 struct s_gs_rl_incoming_connection       *p_in          = NULL;
 276
 277                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 278                         GS_FAILURE("invalid operation");
 279
 280                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 281                                        (char *)&p_cnx,
 282                                        sizeof(p_cnx),
 283                                        (void **)&p_in);
 284
 285                 gras_dict_retrieve(p_in->type_dict, name, (void **)&pp_type);
 286         } else {
 287                 gras_dict_retrieve(p_rl->type_dict, name, (void **)&pp_type);
 288         }
 289
 290         if (!pp_type) {
 291                 DEBUG1("Get type by name '%s': not found",name);
 292                 return NULL;
 293         }
 294
 295         DEBUG1("Get type by name '%s': found",name);
 296         return *pp_type;
 297 }
 298
 299 struct s_gs_type *
 300 gs_rl_bag_get_type_by_code(struct s_gs_type_bag         *p_bag,
 301                            struct s_gs_connection       *p_cnx,
 302                            int                           code) {
 303
 304         struct s_gs_rl_type_bag *p_rl   = p_bag->specific;
 305         struct s_gs_type        *p_type = NULL;
 306
 307         if (p_cnx) {
 308                 struct s_gs_rl_incoming_connection       *p_in          = NULL;
 309
 310                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 311                         GS_FAILURE("invalid operation");
 312
 313                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 314                                        (char *)&p_cnx,
 315                                        sizeof(p_cnx),
 316                                        (void **)&p_in);
 317
 318                 if ((unsigned int)code < gras_dynar_length(p_in->type_dynar)) {
 319                         gras_dynar_get(p_in->type_dynar, code, (void **)&p_type);
 320                 }
 321         } else {
 322                 if ((unsigned int)code < gras_dynar_length(p_rl->type_dynar)) {
 323                         gras_dynar_get(p_rl->type_dynar, code, (void **)&p_type);
 324                 }
 325         }
 326
 327         return p_type;
 328 }
 329
 330 void
 331 gs_rl_bag_mark_type(struct s_gs_type_bag        *p_bag,
 332                     struct s_gs_connection      *p_cnx,
 333                     const char                  *name) {
 334
 335         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 336         struct s_gs_rl_outgoing_connection      *p_out  = NULL;
 337
 338         if (p_cnx->direction != e_gs_connection_direction_outgoing)
 339                 GS_FAILURE("invalid operation");
 340
 341         gras_dict_retrieve_ext(p_rl->outgoing_dict, (char *)&p_cnx, sizeof(p_cnx), (void **)&p_out);
 342
 343         if (!p_out)
 344                 GS_FAILURE("unregistered connection");
 345
 346         gras_dict_insert(p_out->type_marker_dict, name, strdup(name), NULL);
 347 }
 348
 349 int
 350 gs_rl_bag_check_type_mark(struct s_gs_type_bag          *p_bag,
 351                           struct s_gs_connection        *p_cnx,
 352                           const char                    *name) {
 353
 354         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 355         struct s_gs_rl_outgoing_connection      *p_out  = NULL;
 356         char                                    *result = NULL;
 357
 358         if (p_cnx->direction != e_gs_connection_direction_outgoing)
 359                 GS_FAILURE("invalid operation");
 360
 361         gras_dict_retrieve_ext(p_rl->outgoing_dict, (char *)&p_cnx, sizeof(p_cnx), (void **)&p_out);
 362
 363         if (!p_out)
 364                 GS_FAILURE("unregistered connection");
 365
 366         gras_dict_retrieve(p_out->type_marker_dict, name, (void **)&result);
 367
 368         return !!result;
 369 }
 370
 371 /* messages */
 372 void
 373 gs_rl_bag_store_message(struct s_gs_type_bag    *p_bag,
 374                         struct s_gs_connection  *p_cnx,
 375                         struct s_gs_message     *p_message) {
 376
 377         struct s_gs_rl_type_bag  *p_rl          = p_bag->specific;
 378         struct s_gs_message     **pp_message    = NULL;
 379
 380         pp_message       = malloc(sizeof(struct s_gs_message *));
 381         *pp_message = p_message;
 382
 383         if (p_cnx) {
 384                 struct s_gs_rl_incoming_connection      *p_in   = NULL;
 385
 386                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 387                         GS_FAILURE("invalid operation");
 388
 389                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 390                                        (char *)&p_cnx,
 391                                        sizeof(p_cnx),
 392                                        (void **)&p_in);
 393
 394
 395                 p_message->code = gras_dynar_length(p_in->message_dynar);
 396                 gras_dynar_insert_at(p_in->message_dynar, p_message->code, pp_message);
 397                 gras_dict_insert(p_in->message_dict, p_message->name, pp_message, NULL);
 398         } else {
 399                 p_message->code = gras_dynar_length(p_rl->message_dynar);
 400                 gras_dynar_insert_at(p_rl->message_dynar, p_message->code, pp_message);
 401                 gras_dict_insert(p_rl->message_dict, p_message->name, pp_message, NULL);
 402         }
 403 }
 404
 405 void
 406 gs_rl_bag_store_incoming_message(struct s_gs_type_bag   *p_bag,
 407                                  struct s_gs_connection *p_cnx,
 408                                  struct s_gs_message    *p_message) {
 409
 410         struct s_gs_rl_type_bag                  *p_rl          = p_bag->specific;
 411         struct s_gs_rl_incoming_connection       *p_in          = NULL;
 412         struct s_gs_message                     **pp_message    = NULL;
 413
 414         if (p_cnx->direction != e_gs_connection_direction_incoming)
 415                 GS_FAILURE("invalid operation");
 416
 417         gras_dict_retrieve_ext(p_rl->incoming_dict,
 418                                (char *)&p_cnx,
 419                                sizeof(p_cnx),
 420                                (void **)&p_in);
 421
 422         pp_message       = malloc(sizeof(struct s_gs_message *));
 423         *pp_message = p_message;
 424
 425         gras_dynar_set(p_in->message_dynar, p_message->code, pp_message);
 426         gras_dict_insert(p_in->message_dict, p_message->name, pp_message, NULL);
 427 }
 428
 429 struct s_gs_message *
 430 gs_rl_bag_get_message_by_name(struct s_gs_type_bag      *p_bag,
 431                               struct s_gs_connection    *p_cnx,
 432                               const char                *name) {
 433
 434         struct s_gs_rl_type_bag  *p_rl          = p_bag->specific;
 435         struct s_gs_message     **pp_message    = NULL;
 436
 437         if (p_cnx) {
 438                 struct s_gs_rl_incoming_connection       *p_in          = NULL;
 439
 440                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 441                         GS_FAILURE("invalid operation");
 442
 443                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 444                                        (char *)&p_cnx,
 445                                        sizeof(p_cnx),
 446                                        (void **)&p_in);
 447
 448                 gras_dict_retrieve(p_in->message_dict, name, (void **)&pp_message);
 449         } else {
 450                 gras_dict_retrieve(p_rl->message_dict, name, (void **)&pp_message);
 451         }
 452
 453         if (!pp_message) {
 454                 return NULL;
 455         }
 456
 457         return *pp_message;
 458 }
 459
 460 struct s_gs_message *
 461 gs_rl_bag_get_message_by_code(struct s_gs_type_bag      *p_bag,
 462                               struct s_gs_connection    *p_cnx,
 463                               int                        code) {
 464
 465         struct s_gs_rl_type_bag *p_rl   = p_bag->specific;
 466         struct s_gs_message     *p_message      = NULL;
 467
 468         if (p_cnx) {
 469                 struct s_gs_rl_incoming_connection       *p_in          = NULL;
 470
 471                 if (p_cnx->direction != e_gs_connection_direction_incoming)
 472                         GS_FAILURE("invalid operation");
 473
 474                 gras_dict_retrieve_ext(p_rl->incoming_dict,
 475                                        (char *)&p_cnx,
 476                                        sizeof(p_cnx),
 477                                        (void **)&p_in);
 478
 479                 if ((unsigned int)code < gras_dynar_length(p_in->message_dynar)) {
 480                         gras_dynar_get(p_in->message_dynar, code, (void **)&p_message);
 481                 }
 482         } else {
 483                 if ((unsigned int)code < gras_dynar_length(p_rl->message_dynar)) {
 484                         gras_dynar_get(p_rl->message_dynar, code, (void **)&p_message);
 485                 }
 486         }
 487
 488         return p_message;
 489 }
 490
 491 void
 492 gs_rl_bag_mark_message(struct s_gs_type_bag     *p_bag,
 493                        struct s_gs_connection   *p_cnx,
 494                        const char               *name) {
 495
 496         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 497         struct s_gs_rl_outgoing_connection      *p_out  = NULL;
 498
 499         if (p_cnx->direction != e_gs_connection_direction_outgoing)
 500                 GS_FAILURE("invalid operation");
 501
 502         gras_dict_retrieve_ext(p_rl->outgoing_dict, (char *)&p_cnx, sizeof(p_cnx), (void **)&p_out);
 503
 504         if (!p_out)
 505                 GS_FAILURE("unregistered connection");
 506
 507         gras_dict_insert(p_out->message_marker_dict, name, strdup(name), NULL);
 508 }
 509
 510 int
 511 gs_rl_bag_check_message_mark(struct s_gs_type_bag       *p_bag,
 512                              struct s_gs_connection     *p_cnx,
 513                              const char                 *name) {
 514
 515         struct s_gs_rl_type_bag                 *p_rl   = p_bag->specific;
 516         struct s_gs_rl_outgoing_connection      *p_out  = NULL;
 517         char                                    *result = NULL;
 518
 519         if (p_cnx->direction != e_gs_connection_direction_outgoing)
 520                 GS_FAILURE("invalid operation");
 521
 522         gras_dict_retrieve_ext(p_rl->outgoing_dict, (char *)&p_cnx, sizeof(p_cnx), (void **)&p_out);
 523
 524         if (!p_out)
 525                 GS_FAILURE("unregistered connection");
 526
 527         gras_dict_retrieve(p_out->message_marker_dict, name, (void **)&result);
 528
 529         return !!result;
 530 }
 531
 532