src/cm/cm_tkns.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18 \f
  19 /********************************************************************20**
  20
  21      Name:     general layer
  22
  23      Type:     C file
  24
  25      Desc:     Packing/Unpacking for structures, defined in cm_tkns.x
  26
  27      File:     cm_tkns.c
  28
  29 *********************************************************************21*/
  30 \f
  31 /* header include files (.h) */
  32
  33 #include "envopt.h"        /* environment options */
  34 #include "envdep.h"        /* environment dependent */
  35 #include "envind.h"        /* environment independent */
  36
  37 #include "gen.h"           /* general layer */
  38 #include "ssi.h"           /* system services */
  39 #include "cm_mblk.h"
  40 #include "cm_tkns.h"       /* common tokens */
  41
  42 /* header/extern include files (.x) */
  43
  44 #include "gen.x"           /* general layer */
  45 #include "ssi.x"           /* system services */
  46 #include "cm_mblk.x"
  47 #include "cm_tkns.x"       /* common tokens */
  48
  49 \f
  50
  51 /*
  52  *      PACKING FUNCTIONS
  53  */
  54
  55 \f
  56 /*
  57  *
  58  *      Fun:   cmPkTknS16
  59  *
  60  *      Desc:  This function unpacks a token S16
  61  *
  62  *      Ret:   ROK      - ok
  63  *
  64  *      Notes: None
  65  *
  66         File:  cm_tkns.c
  67  *
  68  */
  69 #ifdef ANSI
  70 PUBLIC S16 cmPkTknS16
  71 (
  72 TknS16 *tknS16,             /* token S16 */
  73 Buffer *mBuf                /* message buffer */
  74 )
  75 #else
  76 PUBLIC S16 cmPkTknS16(tknS16, mBuf)
  77 TknS16 *tknS16;             /* token S16 */
  78 Buffer *mBuf;               /* message buffer */
  79 #endif
  80 {
  81    TRC2(cmPkTknS16)
  82
  83    if (tknS16->pres)
  84    {
  85       /* Value */
  86       CMCHKPK(SPkS16, tknS16->val, mBuf);
  87    }
  88
  89    /* Token Header */
  90    CMCHKPK(SPkU8, tknS16->pres, mBuf);
  91
  92    RETVALUE(ROK);
  93 } /* end of cmPkTknS16 */
  94
  95 \f
  96 /*
  97  *
  98  *      Fun:   cmPkTknBStr32
  99  *
 100  *      Desc:  This function packs a token bit string of size 32
 101  *
 102  *      Ret:   ROK      - ok
 103  *
 104  *      Notes: None
 105  *
 106         File:  cm_tkns.c
 107  *
 108  */
 109
 110 #ifdef ANSI
 111 PUBLIC S16 cmPkTknBStr32
 112 (
 113 TknBStr32 *tknStr,             /* token string */
 114 Buffer    *mBuf                /* message buffer */
 115 )
 116 #else
 117 PUBLIC S16 cmPkTknBStr32(tknStr, mBuf)
 118 TknBStr32 *tknStr;             /* token string */
 119 Buffer    *mBuf;               /* message buffer */
 120 #endif
 121 {
 122    TRC2(cmPkTknBStr32)
 123
 124    CMPKTKNBSTR(tknStr, mBuf);
 125
 126    RETVALUE(ROK);
 127
 128 } /* end of cmPkTknBStr32 */
 129
 130 /*
 131  *
 132  *      Fun:   cmPkTknStr8
 133  *
 134  *      Desc:  This function packs a token string of size 8
 135  *
 136  *      Ret:   ROK      - ok
 137  *
 138  *      Notes: None
 139  *
 140         File:  cm_tkns.c
 141  *
 142  */
 143
 144 #ifdef ANSI
 145 PUBLIC S16 cmPkTknStr8
 146 (
 147 TknStr8 *tknStr,             /* token string */
 148 Buffer  *mBuf                /* message buffer */
 149 )
 150 #else
 151 PUBLIC S16 cmPkTknStr8(tknStr, mBuf)
 152 TknStr8 *tknStr;             /* token string */
 153 Buffer  *mBuf;               /* message buffer */
 154 #endif
 155 {
 156    TRC2(cmPkTknStr8)
 157
 158    CMPKTKNSTR(tknStr, mBuf);
 159
 160    RETVALUE(ROK);
 161
 162 } /* end of cmPkTknStr8 */
 163
 164 \f
 165 /*
 166  *
 167  *      Fun:   cmPkTknStr16
 168  *
 169  *      Desc:  This function packs a token string of size 16
 170  *
 171  *      Ret:   ROK      - ok
 172  *
 173  *      Notes: None
 174  *
 175         File:  cm_tkns.c
 176  *
 177  */
 178
 179 #ifdef ANSI
 180 PUBLIC S16 cmPkTknStr16
 181 (
 182 TknStr16 *tknStr,             /* token string */
 183 Buffer   *mBuf                /* message buffer */
 184 )
 185 #else
 186 PUBLIC S16 cmPkTknStr16(tknStr, mBuf)
 187 TknStr16 *tknStr;             /* token string */
 188 Buffer   *mBuf;               /* message buffer */
 189 #endif
 190 {
 191    TRC2(cmPkTknStr16)
 192
 193    CMPKTKNSTR(tknStr, mBuf);
 194
 195    RETVALUE(ROK);
 196
 197 } /* end of cmPkTknStr16 */
 198
 199 \f
 200 /*
 201  *
 202  *      Fun:   cmPkTknStrOSXL
 203  *
 204  *      Desc:  This function packs a Long Octet string
 205  *
 206  *      Ret:   ROK      - ok
 207  *
 208  *      Notes: None
 209  *
 210         File:  cm_tkns.c
 211  *
 212  */
 213
 214 #ifdef ANSI
 215 PUBLIC S16 cmPkTknStrOSXL
 216 (
 217 TknStrOSXL *tknStr,             /* token string */
 218 Buffer     *mBuf                /* message buffer */
 219 )
 220 #else
 221 PUBLIC S16 cmPkTknStrOSXL(tknStr, mBuf)
 222 TknStrOSXL *tknStr;             /* token string */
 223 Buffer     *mBuf;               /* message buffer */
 224 #endif
 225 {
 226    U16 ndx;
 227
 228    TRC2(cmPkTknStrOSXL)
 229
 230    if(tknStr->pres)
 231    {
 232       /* Value */
 233       for (ndx = 0; ndx < tknStr->len; ndx++)
 234       {
 235          CMCHKPK(SPkU8, tknStr->val[ndx], mBuf);
 236       }
 237       /* Length */
 238       CMCHKPK(SPkU16, tknStr->len, mBuf);
 239    }
 240    /* Token Header */
 241    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 242
 243    RETVALUE(ROK);
 244
 245 } /* end of cmPkTknStrOSXL */
 246
 247
 248 \f
 249 /*
 250  *
 251  *      Fun:   cmPkTknStrBSXL
 252  *
 253  *      Desc:  This function packs a Long bit string
 254  *
 255  *      Ret:   ROK      - ok
 256  *
 257  *      Notes: None
 258  *
 259         File:  cm_tkns.c
 260  *
 261  */
 262
 263 #ifdef ANSI
 264 PUBLIC S16 cmPkTknStrBSXL
 265 (
 266 TknStrBSXL *tknStr,             /* token string */
 267 Buffer     *mBuf              /* message buffer */
 268 )
 269 #else
 270 PUBLIC S16 cmPkTknStrBSXL(tknStr, mBuf)
 271 TknStrBSXL *tknStr;             /* token string */
 272 Buffer     *mBuf;               /* message buffer */
 273 #endif
 274 {
 275    U16 ndx;
 276    U16 len;
 277
 278    TRC2(cmPkTknStrBSXL)
 279
 280    if(tknStr->pres)
 281    {
 282       if (tknStr->len % 8)
 283          len = (tknStr->len/8) + 1;
 284       else
 285          len = (tknStr->len/8);
 286
 287       /* Value */
 288       for (ndx = 0; ndx < len; ndx++)
 289       {
 290          CMCHKPK(SPkU8, tknStr->val[ndx], mBuf);
 291       }
 292       /* Length */
 293       CMCHKPK(SPkU16, tknStr->len, mBuf);
 294    }
 295    /* Token Header */
 296    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 297
 298    RETVALUE(ROK);
 299
 300 } /* end of cmPkTknStrBSXL */
 301
 302 \f
 303 /*
 304  *
 305  *      Fun:   cmPkTknStrBMP4
 306  *
 307  *      Desc:  This function packs a BMP token string of size 4
 308  *
 309  *      Ret:   ROK      - ok
 310  *
 311  *      Notes: None
 312  *
 313         File:  cm_tkns.c
 314  *
 315  */
 316
 317 #ifdef ANSI
 318 PUBLIC S16 cmPkTknStrBMP4
 319 (
 320 TknStrBMP4 *tknStr,             /* token string */
 321 Buffer     *mBuf                /* message buffer */
 322 )
 323 #else
 324 PUBLIC S16 cmPkTknStrBMP4(tknStr, mBuf)
 325 TknStrBMP4 *tknStr;             /* token string */
 326 Buffer     *mBuf;               /* message buffer */
 327 #endif
 328 {
 329    U8 ndx;
 330
 331    TRC2(cmPkTknStrBMP4)
 332
 333    if(tknStr->pres)
 334    {
 335       /* Value */
 336       for (ndx = 0; ndx < tknStr->len; ndx++)
 337       {
 338          CMCHKPK(SPkU16, tknStr->val[ndx], mBuf);
 339       }
 340
 341       /* Length */
 342       CMCHKPK(SPkU8, tknStr->len, mBuf);
 343    }
 344
 345    /* Token Header */
 346    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 347
 348    RETVALUE(ROK);
 349 } /* end of cmPkTknStrBMP4 */
 350
 351 \f
 352 /*
 353  *
 354  *      Fun:   cmPkTknStrBMPXL
 355  *
 356  *      Desc:  This function packs a Long BMP Octet string
 357  *
 358  *      Ret:   ROK      - ok
 359  *
 360  *      Notes: None
 361  *
 362         File:  cm_tkns.c
 363  *
 364  */
 365
 366 #ifdef ANSI
 367 PUBLIC S16 cmPkTknStrBMPXL
 368 (
 369 TknStrBMPXL *tknStr,             /* token string */
 370 Buffer     *mBuf                /* message buffer */
 371 )
 372 #else
 373 PUBLIC S16 cmPkTknStrBMPXL(tknStr, mBuf)
 374 TknStrBMPXL *tknStr;             /* token string */
 375 Buffer      *mBuf;               /* message buffer */
 376 #endif
 377 {
 378    U16 ndx;
 379
 380    TRC2(cmPkTknStrBMPXL)
 381
 382    if(tknStr->pres)
 383    {
 384       /* Value */
 385       for (ndx = 0; ndx < tknStr->len; ndx++)
 386       {
 387          CMCHKPK(SPkU16, tknStr->val[ndx], mBuf);
 388       }
 389       /* Length */
 390       CMCHKPK(SPkU16, tknStr->len, mBuf);
 391    }
 392    /* Token Header */
 393    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 394
 395    RETVALUE(ROK);
 396 } /* end of cmPkTknStrBMPXL */
 397
 398 \f
 399 /*
 400  *
 401  *      Fun:   cmPkTknStrUNI4
 402  *
 403  *      Desc:  This function packs a UNI token string of size 4
 404  *
 405  *      Ret:   ROK      - ok
 406  *
 407  *      Notes: None
 408  *
 409         File:  cm_tkns.c
 410  *
 411  */
 412
 413 #ifdef ANSI
 414 PUBLIC S16 cmPkTknStrUNI4
 415 (
 416 TknStrUNI4 *tknStr,             /* token string */
 417 Buffer     *mBuf                /* message buffer */
 418 )
 419 #else
 420 PUBLIC S16 cmPkTknStrUNI4(tknStr, mBuf)
 421 TknStrUNI4 *tknStr;             /* token string */
 422 Buffer     *mBuf;               /* message buffer */
 423 #endif
 424 {
 425    U8 ndx;
 426
 427    TRC2(cmPkTknStrUNI4)
 428
 429    if(tknStr->pres)
 430    {
 431       /* Value */
 432       for (ndx = 0; ndx < tknStr->len; ndx++)
 433       {
 434          CMCHKPK(SPkU32, tknStr->val[ndx], mBuf);
 435       }
 436
 437       /* Length */
 438       CMCHKPK(SPkU8, tknStr->len, mBuf);
 439    }
 440
 441    /* Token Header */
 442    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 443
 444    RETVALUE(ROK);
 445 } /* end of cmPkTknStrUNI4 */
 446
 447 \f
 448 /*
 449  *
 450  *      Fun:   cmPkTknStrUNIXL
 451  *
 452  *      Desc:  This function packs a Long UNI Octet string
 453  *
 454  *      Ret:   ROK      - ok
 455  *
 456  *      Notes: None
 457  *
 458         File:  cm_tkns.c
 459  *
 460  */
 461
 462 #ifdef ANSI
 463 PUBLIC S16 cmPkTknStrUNIXL
 464 (
 465 TknStrUNIXL *tknStr,             /* token string */
 466 Buffer     *mBuf                /* message buffer */
 467 )
 468 #else
 469 PUBLIC S16 cmPkTknStrUNIXL(tknStr, mBuf)
 470 TknStrUNIXL *tknStr;             /* token string */
 471 Buffer      *mBuf;               /* message buffer */
 472 #endif
 473 {
 474    U16 ndx;
 475
 476    TRC2(cmPkTknStrUNIXL)
 477
 478    if(tknStr->pres)
 479    {
 480       /* Value */
 481       for (ndx = 0; ndx < tknStr->len; ndx++)
 482       {
 483          CMCHKPK(SPkU32, tknStr->val[ndx], mBuf);
 484       }
 485       /* Length */
 486       CMCHKPK(SPkU16, tknStr->len, mBuf);
 487    }
 488    /* Token Header */
 489    CMCHKPK(SPkU8, tknStr->pres, mBuf);
 490
 491    RETVALUE(ROK);
 492 } /* end of cmPkTknStrUNIXL */
 493 \f
 494 /*
 495  *      UNPACKING FUNCTIONS
 496  */
 497
 498 \f
 499 /*
 500  *
 501  *      Fun:   cmUnpkTknS16
 502  *
 503  *      Desc:  This function unpacks a token S16
 504  *
 505  *      Ret:   ROK      - ok
 506  *
 507  *      Notes: None
 508  *
 509         File:  cm_tkns.c
 510  *
 511  */
 512 #ifdef ANSI
 513 PUBLIC S16 cmUnpkTknS16
 514 (
 515 TknS16 *tknS16,             /* token S16 */
 516 Buffer *mBuf                /* message buffer */
 517 )
 518 #else
 519 PUBLIC S16 cmUnpkTknS16(tknS16, mBuf)
 520 TknS16 *tknS16;             /* token S16 */
 521 Buffer *mBuf;               /* message buffer */
 522 #endif
 523 {
 524    TRC2(cmUnpkTknS16)
 525
 526    /* Token Header */
 527    CMCHKUNPK(SUnpkU8, &tknS16->pres, mBuf);
 528
 529    if (tknS16->pres)
 530    {
 531       /* Value */
 532       CMCHKUNPK(SUnpkS16, &tknS16->val, mBuf);
 533    }
 534
 535    RETVALUE(ROK);
 536 } /* end of cmUnpkTknS16 */
 537
 538 \f
 539 /*
 540  *
 541  *      Fun:   cmUnpkTknBStr32
 542  *
 543  *      Desc:  This function packs a token bit string of size 32
 544  *
 545  *      Ret:   ROK      - ok
 546  *
 547  *      Notes: None
 548  *
 549         File:  cm_tkns.c
 550  *
 551  */
 552
 553 #ifdef ANSI
 554 PUBLIC S16 cmUnpkTknBStr32
 555 (
 556 TknBStr32 *tknStr,             /* token string */
 557 Buffer    *mBuf                /* message buffer */
 558 )
 559 #else
 560 PUBLIC S16 cmUnpkTknBStr32(tknStr, mBuf)
 561 TknBStr32 *tknStr;             /* token string */
 562 Buffer    *mBuf;               /* message buffer */
 563 #endif
 564 {
 565    TRC2(cmUnpkTknBStr32)
 566
 567    CMUNPKTKNBSTR(tknStr, mBuf);
 568
 569    RETVALUE(ROK);
 570
 571 } /* end of cmUnpkTknBStr32 */
 572
 573 \f
 574 /*
 575  *
 576  *      Fun:   cmUnpkTknStr8
 577  *
 578  *      Desc:  This function packs a token string of size 8
 579  *
 580  *      Ret:   ROK      - ok
 581  *
 582  *      Notes: None
 583  *
 584         File:  cm_tkns.c
 585  *
 586  */
 587
 588 #ifdef ANSI
 589 PUBLIC S16 cmUnpkTknStr8
 590 (
 591 TknStr8 *tknStr,             /* token string */
 592 Buffer  *mBuf                /* message buffer */
 593 )
 594 #else
 595 PUBLIC S16 cmUnpkTknStr8(tknStr, mBuf)
 596 TknStr8 *tknStr;             /* token string */
 597 Buffer  *mBuf;               /* message buffer */
 598 #endif
 599 {
 600    TRC2(cmUnpkTknStr8)
 601
 602    CMUNPKTKNSTR(tknStr, mBuf);
 603
 604    RETVALUE(ROK);
 605
 606 } /* end of cmUnpkTknStr8 */
 607
 608 \f
 609 /*
 610  *
 611  *      Fun:   cmUnpkTknStr16
 612  *
 613  *      Desc:  This function packs a token string of size 16
 614  *
 615  *      Ret:   ROK      - ok
 616  *
 617  *      Notes: None
 618  *
 619         File:  cm_tkns.c
 620  *
 621  */
 622
 623 #ifdef ANSI
 624 PUBLIC S16 cmUnpkTknStr16
 625 (
 626 TknStr16 *tknStr,             /* token string */
 627 Buffer   *mBuf                /* message buffer */
 628 )
 629 #else
 630 PUBLIC S16 cmUnpkTknStr16(tknStr, mBuf)
 631 TknStr16 *tknStr;             /* token string */
 632 Buffer   *mBuf;               /* message buffer */
 633 #endif
 634 {
 635    TRC2(cmUnpkTknStr16)
 636
 637    CMUNPKTKNSTR(tknStr, mBuf);
 638
 639    RETVALUE(ROK);
 640
 641 } /* end of cmUnpkTknStr16 */
 642
 643 \f
 644 /*
 645  *
 646  *      Fun:   cmUnpkTknStrOSXL
 647  *
 648  *      Desc:  This function packs a long octet token string
 649  *
 650  *      Ret:   ROK      - ok
 651  *
 652  *      Notes: None
 653  *
 654         File:  cm_tkns.c
 655  *
 656  */
 657
 658 #ifdef ANSI
 659 PUBLIC S16 cmUnpkTknStrOSXL
 660 (
 661 TknStrOSXL *tknStr,             /* token string */
 662 Buffer     *mBuf,               /* message buffer */
 663 Ptr         ptr                 /* pointer to memory control block */
 664 )
 665 #else
 666 PUBLIC S16 cmUnpkTknStrOSXL(tknStr, mBuf, ptr)
 667 TknStrOSXL *tknStr;             /* token string */
 668 Buffer     *mBuf;               /* message buffer */
 669 Ptr         ptr;                /* pointer to control memory block */
 670 #endif
 671 {
 672    U16 ndx;
 673
 674    TRC2(cmUnpkTknStrOSXL)
 675
 676    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 677
 678    if(tknStr->pres)
 679    {
 680       /* Length */
 681       CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
 682
 683       if( cmGetMem(ptr, tknStr->len, (Ptr *)&tknStr->val) != ROK)
 684       {
 685          RETVALUE(RFAILED);
 686       }
 687       /* Value */
 688       for (ndx = 1; ndx <= tknStr->len; ndx++)
 689       {
 690          CMCHKUNPK(SUnpkU8, &tknStr->val[tknStr->len - ndx], mBuf);
 691       }
 692    }
 693
 694    RETVALUE(ROK);
 695
 696 } /* end of cmUnpkTknStrOSXL */
 697
 698
 699 \f
 700 /*
 701  *
 702  *      Fun:   cmUnpkTknStrBSXL
 703  *
 704  *      Desc:  This function packs a long bit token string
 705  *
 706  *      Ret:   ROK      - ok
 707  *
 708  *      Notes: None
 709  *
 710         File:  cm_tkns.c
 711  *
 712  */
 713
 714 #ifdef ANSI
 715 PUBLIC S16 cmUnpkTknStrBSXL
 716 (
 717 TknStrBSXL *tknStr,             /* token string */
 718 Ptr         ptr,                /* pointer to memory control block */
 719 Buffer     *mBuf                /* message buffer */
 720 )
 721 #else
 722 PUBLIC S16 cmUnpkTknStrBSXL(tknStr, ptr, mBuf)
 723 TknStrBSXL *tknStr;             /* token string */
 724 Ptr         ptr;                /* pointer to control memory block */
 725 Buffer     *mBuf;               /* message buffer */
 726 #endif
 727 {
 728    U16 ndx;
 729    U16 len;
 730
 731    TRC2(cmUnpkTknStrBSXL)
 732
 733    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 734
 735    if(tknStr->pres)
 736    {
 737       /* Length */
 738       CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
 739
 740       if (tknStr->len % 8)
 741          len = (tknStr->len/8) + 1;
 742       else
 743          len = (tknStr->len/8);
 744
 745       if( cmGetMem(ptr, len, (Ptr *)&tknStr->val) != ROK)
 746       {
 747          RETVALUE(RFAILED);
 748       }
 749       /* Value */
 750       for (ndx = 1; ndx <= len; ndx++)
 751       {
 752          CMCHKUNPK(SUnpkU8, &tknStr->val[len - ndx], mBuf);
 753       }
 754    }
 755
 756    RETVALUE(ROK);
 757
 758 } /* end of cmUnpkTknStrBSXL */
 759
 760 \f
 761 /*
 762  *
 763  *      Fun:   cmUnpkTknStrBMP4
 764  *
 765  *      Desc:  This function unpacks a BMP token string of size 4
 766  *
 767  *      Ret:   ROK      - ok
 768  *
 769  *      Notes: None
 770  *
 771         File:  cm_tkns.c
 772  *
 773  */
 774
 775 #ifdef ANSI
 776 PUBLIC S16 cmUnpkTknStrBMP4
 777 (
 778 TknStrBMP4 *tknStr,             /* token string */
 779 Buffer     *mBuf                /* message buffer */
 780 )
 781 #else
 782 PUBLIC S16 cmUnpkTknStrBMP4(tknStr, mBuf)
 783 TknStrBMP4 *tknStr;             /* token string */
 784 Buffer     *mBuf;               /* message buffer */
 785 #endif
 786 {
 787    U8 ndx;
 788
 789    TRC2(cmUnpkTknStrBMP4)
 790
 791    /* Token Header */
 792    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 793
 794    if(tknStr->pres)
 795    {
 796       /* Length */
 797       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
 798
 799       /* Value */
 800       for (ndx = 1; ndx <= tknStr->len; ndx++)
 801       {
 802          CMCHKUNPK(SUnpkU16, &tknStr->val[tknStr->len - ndx], mBuf);
 803       }
 804    }
 805
 806    RETVALUE(ROK);
 807 } /* end of cmUnpkTknStrBMP4 */
 808
 809 \f
 810 /*
 811  *
 812  *      Fun:   cmUnpkTknStrBMPXL
 813  *
 814  *      Desc:  This function packs a long octet token string
 815  *
 816  *      Ret:   ROK      - ok
 817  *
 818  *      Notes: None
 819  *
 820         File:  cm_tkns.c
 821  *
 822  */
 823
 824 #ifdef ANSI
 825 PUBLIC S16 cmUnpkTknStrBMPXL
 826 (
 827 TknStrBMPXL *tknStr,             /* token string */
 828 Buffer      *mBuf,               /* message buffer */
 829 Ptr          ptr                 /* pointer to memory control block */
 830 )
 831 #else
 832 PUBLIC S16 cmUnpkTknStrBMPXL(tknStr, mBuf, ptr)
 833 TknStrBMPXL *tknStr;             /* token string */
 834 Buffer      *mBuf;               /* message buffer */
 835 Ptr          ptr;                /* pointer to control memory block */
 836 #endif
 837 {
 838    U16 ndx;
 839
 840    TRC2(cmUnpkTknStrBMPXL)
 841
 842    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 843
 844    if(tknStr->pres)
 845    {
 846       /* Length */
 847       CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
 848
 849       /* Each BMP Character is 2 octet long */
 850       if( cmGetMem(ptr, 2*(tknStr->len), (Ptr *)&tknStr->val) != ROK)
 851       {
 852          RETVALUE(RFAILED);
 853       }
 854       /* Value */
 855       for (ndx = 1; ndx <= tknStr->len; ndx++)
 856       {
 857          CMCHKUNPK(SUnpkU16, &tknStr->val[tknStr->len - ndx], mBuf);
 858       }
 859    }
 860
 861    RETVALUE(ROK);
 862
 863 } /* end of cmUnpkTknStrBMPXL */
 864
 865 \f
 866 /*
 867  *
 868  *      Fun:   cmUnpkTknStrUNI4
 869  *
 870  *      Desc:  This function unpacks a UNI token string of size 4
 871  *
 872  *      Ret:   ROK      - ok
 873  *
 874  *      Notes: None
 875  *
 876         File:  cm_tkns.c
 877  *
 878  */
 879
 880 #ifdef ANSI
 881 PUBLIC S16 cmUnpkTknStrUNI4
 882 (
 883 TknStrUNI4 *tknStr,             /* token string */
 884 Buffer     *mBuf                /* message buffer */
 885 )
 886 #else
 887 PUBLIC S16 cmUnpkTknStrUNI4(tknStr, mBuf)
 888 TknStrUNI4 *tknStr;             /* token string */
 889 Buffer     *mBuf;               /* message buffer */
 890 #endif
 891 {
 892    U8 ndx;
 893
 894    TRC2(cmUnpkTknStrUNI4)
 895
 896    /* Token Header */
 897    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 898
 899    if(tknStr->pres)
 900    {
 901       /* Length */
 902       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
 903
 904       /* Value */
 905       for (ndx = 1; ndx <= tknStr->len; ndx++)
 906       {
 907          CMCHKUNPK(SUnpkU32, &tknStr->val[tknStr->len - ndx], mBuf);
 908       }
 909    }
 910
 911    RETVALUE(ROK);
 912 } /* end of cmUnpkTknStrUNI4 */
 913
 914 \f
 915 /*
 916  *
 917  *      Fun:   cmUnpkTknStrUNIXL
 918  *
 919  *      Desc:  This function packs a long octet token string
 920  *
 921  *      Ret:   ROK      - ok
 922  *
 923  *      Notes: None
 924  *
 925         File:  cm_tkns.c
 926  *
 927  */
 928
 929 #ifdef ANSI
 930 PUBLIC S16 cmUnpkTknStrUNIXL
 931 (
 932 TknStrUNIXL *tknStr,             /* token string */
 933 Buffer      *mBuf,               /* message buffer */
 934 Ptr          ptr                 /* pointer to memory control block */
 935 )
 936 #else
 937 PUBLIC S16 cmUnpkTknStrUNIXL(tknStr, mBuf, ptr)
 938 TknStrUNIXL *tknStr;             /* token string */
 939 Buffer      *mBuf;               /* message buffer */
 940 Ptr          ptr;                /* pointer to control memory block */
 941 #endif
 942 {
 943    U16 ndx;
 944
 945    TRC2(cmUnpkTknStrUNIXL)
 946
 947    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
 948
 949    if(tknStr->pres)
 950    {
 951       /* Length */
 952       CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
 953
 954       /* Each UNI Character is 4 octets long */
 955       if( cmGetMem(ptr, 4*tknStr->len, (Ptr *)&tknStr->val) != ROK)
 956       {
 957          RETVALUE(RFAILED);
 958       }
 959       /* Value */
 960       for (ndx = 1; ndx <= tknStr->len; ndx++)
 961       {
 962          CMCHKUNPK(SUnpkU32, &tknStr->val[tknStr->len - ndx], mBuf);
 963       }
 964    }
 965
 966    RETVALUE(ROK);
 967
 968 } /* end of cmUnpkTknStrUNIXL */
 969
 970 /**********************************************************************
 971          End of file
 972 **********************************************************************/