src/mt/ss_pack.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:     System Services -- packing
  22
  23      Type:     C source file
  24
  25      Desc:     Source code for System Services packing functions.
  26
  27      File:     ss_pack.c
  28
  29 *********************************************************************21*/
  30
  31 \f
  32 /* header include files (.h) */
  33
  34 #include "envopt.h"        /* environment options */
  35 #include "envdep.h"        /* environment dependent */
  36 #include "envind.h"        /* environment independent */
  37
  38 #include "gen.h"           /* general layer */
  39 #include "ssi.h"           /* system services */
  40
  41 #include "ss_err.h"        /* errors */
  42 #include "ss_dep.h"        /* implementation-specific */
  43 #include "ss_queue.h"      /* queues */
  44 #include "ss_msg.h"        /* messaging */
  45 #include "ss_mem.h"        /* memory management interface */
  46 #include "ss_gen.h"        /* general */
  47 #include "cm_mem.h"        /* memory management */
  48
  49
  50
  51 /* header/extern include files (.x) */
  52
  53 #include "gen.x"           /* general layer */
  54 #include "ssi.x"           /* system services */
  55
  56 #include "ss_dep.x"        /* implementation-specific */
  57 #include "ss_queue.x"      /* queues */
  58 #include "ss_task.x"       /* tasking */
  59 #include "ss_timer.x"      /* timers */
  60 #include "ss_strm.x"       /* STREAMS */
  61 #include "ss_msg.x"        /* messaging */
  62 #include "ss_mem.x"        /* memory management interface */
  63 #include "ss_drvr.x"       /* driver tasks */
  64 #ifdef SS_LOCKLESS_MEMORY
  65 #include "cm_llist.x"
  66 #include "cm_hash.x"
  67 #include "cm_mem_wl.x"        /* common memory manager */
  68 #else
  69 #include "cm_mem.x"        /* common memory manager */
  70 #endif /* SS_LOCKLESS_MEMORY */
  71 #include "ss_gen.x"        /* general */
  72
  73
  74 \f
  75 /*
  76 *
  77 *       Fun:   SPkS8
  78 *
  79 *       Desc:  This function packs a signed 8 bit value into a message.
  80 *
  81 *       Ret:   ROK      - ok
  82 *              RFAILED  - failed, general (optional)
  83 *              ROUTRES  - failed, out of resources (optional)
  84 *
  85 *       Notes: None
  86 *
  87 *       File:  ss_pack.c
  88 *
  89 */
  90
  91 S16 SPkS8
  92 (
  93 S8 val,                     /* value */
  94 Buffer *mBuf                /* message buffer */
  95 )
  96 {
  97    S16 ret;                 /* return code */
  98    ret = SAddPreMsg((Data) val, mBuf);
  99 #if (ERRCLASS & ERRCLS_ADD_RES)
 100    if (ret != ROK)
 101       SSLOGERROR(ERRCLS_ADD_RES, ESS242, (ErrVal)ret, "SAddPreMsg() failed");
 102 #endif
 103    return (ret);
 104 } /* end of SPkS8 */
 105
 106
 107 \f
 108 /*
 109 *
 110 *       Fun:   oduUnpackUInt8
 111 *
 112 *       Desc:  This function packs an unsigned 8 bit value into a message.
 113 *
 114 *       Ret:   ROK      - ok
 115 *              RFAILED  - failed, general (optional)
 116 *              ROUTRES  - failed, out of resources (optional)
 117 *
 118 *       Notes: None
 119 *
 120 *       File:  ss_pack.c
 121 *
 122 */
 123
 124 S16 oduUnpackUInt8
 125 (
 126 uint8_t val,                     /* value */
 127 Buffer *mBuf                /* message buffer */
 128 )
 129 {
 130    S16 ret;                 /* return code */
 131    ret = SAddPreMsg((Data) val, mBuf);
 132 #if (ERRCLASS & ERRCLS_ADD_RES)
 133    if (ret != ROK)
 134       SSLOGERROR(ERRCLS_ADD_RES, ESS243, (ErrVal)ret, "SAddPreMsg() failed");
 135 #endif
 136    return (ret);
 137 } /* end of oduUnpackUInt8 */
 138 \f
 139 /*
 140 *
 141 *       Fun:   SPkS16
 142 *
 143 *       Desc:  This function packs a signed 16 bit value into a message.
 144 *
 145 *       Ret:   ROK      - ok
 146 *              RFAILED  - failed, general (optional)
 147 *              ROUTRES  - failed, out of resources (optional)
 148 *
 149 *       Notes: None
 150 *
 151 *       File:  ss_pack.c
 152 *
 153 */
 154
 155 S16 SPkS16
 156 (
 157 S16 val,                    /* value */
 158 Buffer *mBuf                /* message buffer */
 159 )
 160 {
 161    Data pkArray[2];         /* array for packing */
 162    S16 ret;                 /* return code */
 163
 164 #ifndef FCSPKINT            /* backward compatibility, packing order */
 165    pkArray[0] = (Data) GetHiByte(val);
 166    pkArray[1] = (Data) GetLoByte(val);
 167 #else                   /* forward compatibility, packing order */
 168    pkArray[1] = (Data) GetHiByte(val);
 169    pkArray[0] = (Data) GetLoByte(val);
 170 #endif
 171    ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
 172 #if (ERRCLASS & ERRCLS_ADD_RES)
 173    if (ret != ROK)
 174       SSLOGERROR(ERRCLS_ADD_RES, ESS244, (ErrVal)ret, "SAddPreMsgMult() failed");
 175 #endif
 176    return (ret);
 177 } /* end of SPkS16 */
 178
 179 \f
 180 /*
 181 *
 182 *       Fun:   oduUnpackUInt16
 183 *
 184 *       Desc:  This function packs an unsigned 16 bit value into a message.
 185 *
 186 *       Ret:   ROK      - ok
 187 *              RFAILED  - failed, general (optional)
 188 *              ROUTRES  - failed, out of resources (optional)
 189 *
 190 *       Notes: None
 191 *
 192 *       File:  ss_pack.c
 193 *
 194 */
 195
 196 S16 oduUnpackUInt16
 197 (
 198 uint16_t val,                    /* value */
 199 Buffer *mBuf                /* message buffer */
 200 )
 201 {
 202    Data pkArray[2];         /* array for packing */
 203    S16 ret;                 /* return code */
 204
 205 #ifndef FCSPKINT            /* backward compatibility, packing order */
 206    pkArray[0] = (Data) GetHiByte(val);
 207    pkArray[1] = (Data) GetLoByte(val);
 208 #else                       /* forward compatibility, packing order */
 209    pkArray[1] = (Data) GetHiByte(val);
 210    pkArray[0] = (Data) GetLoByte(val);
 211 #endif
 212    ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
 213 #if (ERRCLASS & ERRCLS_ADD_RES)
 214    if (ret != ROK)
 215       SSLOGERROR(ERRCLS_ADD_RES, ESS245, (ErrVal)ret, "SAddPreMsgMult() failed");
 216 #endif
 217    return (ret);
 218 } /* end of oduUnpackUInt16 */
 219
 220 \f
 221 /*
 222 *
 223 *       Fun:   SPkS32
 224 *
 225 *       Desc:  This function packs a signed 32 bit value into a message.
 226 *
 227 *       Ret:   ROK      - ok
 228 *              RFAILED  - failed, general (optional)
 229 *              ROUTRES  - failed, out of resources (optional)
 230 *
 231 *       Notes: None
 232 *
 233 *       File:  ss_pack.c
 234 *
 235 */
 236
 237 S16 SPkS32
 238 (
 239 S32 val,                    /* value */
 240 Buffer *mBuf                /* message buffer */
 241 )
 242 {
 243    uint16_t tmp;                 /* temporary value */
 244    Data pkArray[4];         /* packing array */
 245    S16 ret;                 /* return code */
 246
 247 #ifndef FCSPKINT        /* backward compatibility, packing order */
 248    tmp = (uint16_t) GetHiWord(val);
 249    pkArray[0] = (Data) GetHiByte(tmp);
 250    pkArray[1] = (Data) GetLoByte(tmp);
 251    tmp = (uint16_t) GetLoWord(val);
 252    pkArray[2] = (Data) GetHiByte(tmp);
 253    pkArray[3] = (Data) GetLoByte(tmp);
 254 #else                   /* forward compatibility, packing order */
 255    tmp = (uint16_t) GetHiWord(val);
 256    pkArray[3] = (Data) GetHiByte(tmp);
 257    pkArray[2] = (Data) GetLoByte(tmp);
 258    tmp = (uint16_t) GetLoWord(val);
 259    pkArray[1] = (Data) GetHiByte(tmp);
 260    pkArray[0] = (Data) GetLoByte(tmp);
 261 #endif
 262    ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
 263 #if (ERRCLASS & ERRCLS_ADD_RES)
 264    if (ret != ROK)
 265       SSLOGERROR(ERRCLS_ADD_RES, ESS246, (ErrVal)ret, "SAddPreMsgMult() failed");
 266 #endif
 267    return (ret);
 268 } /* end of SPkS32 */
 269
 270 \f
 271 /*
 272 *
 273 *       Fun:   oduUnpackUInt32
 274 *
 275 *       Desc:  This function packs an unsigned 32 bit value into a message.
 276 *
 277 *       Ret:   ROK      - ok
 278 *              RFAILED  - failed, general (optional)
 279 *              ROUTRES  - failed, out of resources (optional)
 280 *
 281 *       Notes: None
 282 *
 283 *       File:  ss_pack.c
 284 *
 285 */
 286
 287 S16 oduUnpackUInt32
 288 (
 289 uint32_t val,                    /* value */
 290 Buffer *mBuf                /* message buffer */
 291 )
 292 {
 293    uint16_t tmp;                 /* temporary value */
 294    Data pkArray[4];         /* packing array */
 295    S16 ret;                 /* return code */
 296
 297 #ifndef FCSPKINT        /* backward compatibility, packing order */
 298    tmp = (uint16_t) GetHiWord(val);
 299    pkArray[0] = (Data) GetHiByte(tmp);
 300    pkArray[1] = (Data) GetLoByte(tmp);
 301    tmp = (uint16_t) GetLoWord(val);
 302    pkArray[2] = (Data) GetHiByte(tmp);
 303    pkArray[3] = (Data) GetLoByte(tmp);
 304 #else                   /* forward compatibility, packing order */
 305    tmp = (uint16_t) GetHiWord(val);
 306    pkArray[3] = (Data) GetHiByte(tmp);
 307    pkArray[2] = (Data) GetLoByte(tmp);
 308    tmp = (uint16_t) GetLoWord(val);
 309    pkArray[1] = (Data) GetHiByte(tmp);
 310    pkArray[0] = (Data) GetLoByte(tmp);
 311 #endif
 312    ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
 313 #if (ERRCLASS & ERRCLS_ADD_RES)
 314    if (ret != ROK)
 315       SSLOGERROR(ERRCLS_ADD_RES, ESS247, (ErrVal)ret, "SAddPreMsgMult() failed");
 316 #endif
 317    return (ret);
 318 } /* end of oduUnpackUInt32 */
 319
 320 /*ss038.103  1. Added Floating point support*/
 321 #ifdef SS_FLOAT
 322 /*
 323 *
 324 *       Fun:   SPkF32
 325 *
 326 *       Desc:  This function packs an 32 bit ieee-754 format float value into a message.
 327 *
 328 *       Ret:   ROK      - ok
 329 *              RFAILED  - failed, general (optional)
 330 *              ROUTRES  - failed, out of resources (optional)
 331 *
 332 *       Notes: None
 333 *
 334 *       File:  ss_pack.c
 335 *
 336 */
 337
 338 S16 SPkF32
 339 (
 340 F32 val,                    /* value */
 341 Buffer *mBuf                /* message buffer */
 342 )
 343 {
 344    S16  ret;                /* return code */
 345    S8   tmpArray[15];       /* temporary array */
 346 #ifdef FCSPKINT             /* backward compatibility, packing order */
 347    S32  tIdx = 14;          /* counters */
 348    S32  kIdx = 0;           /* counters */
 349    S8   pkArray[15];        /* packing array */
 350 #endif /*FCSPKINT*/
 351
 352    sprintf(tmpArray, "%.7e", val);
 353
 354 #ifndef FCSPKINT            /* backward compatibility, packing order */
 355    ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
 356 #else
 357    while(tIdx >= 0)
 358    {
 359       pkArray[kIdx] = tmpArray[tIdx];
 360       tIdx--; kIdx++;
 361    }
 362    ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 15, mBuf);
 363 #endif
 364
 365
 366 #if (ERRCLASS & ERRCLS_ADD_RES)
 367    if (ret != ROK)
 368       SSLOGERROR(ERRCLS_ADD_RES, ESS248, (ErrVal)ret, "SAddPreMsgMult() failed");
 369 #endif
 370    return (ret);
 371 } /* end of SPkF32 */
 372
 373 /*
 374 *
 375 *       Fun:   SPkF64
 376 *
 377 *       Desc:  This function packs an 64 bit ieee-754 format float value into a message.
 378 *
 379 *       Ret:   ROK      - ok
 380 *              RFAILED  - failed, general (optional)
 381 *              ROUTRES  - failed, out of resources (optional)
 382 *
 383 *       Notes: None
 384 *
 385 *       File:  ss_pack.c
 386 *
 387 */
 388
 389 S16 SPkF64
 390 (
 391 F64 val,                    /* value */
 392 Buffer *mBuf                /* message buffer */
 393 )
 394 {
 395
 396    S16  ret;                /* return code */
 397    S8   tmpArray[25];       /* temporary array */
 398 #ifdef FCSPKINT             /* backward compatibility, packing order */
 399    S32  tIdx = 24;          /* counters */
 400    S32  kIdx = 0;           /* counters */
 401    S8   pkArray[25];        /* packing array */
 402 #endif /*FCSPKINT*/
 403
 404    sprintf(tmpArray, "%.16le", val);
 405
 406 #ifndef FCSPKINT            /* backward compatibility, packing order */
 407    ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
 408 #else
 409    while(tIdx >= 0)
 410    {
 411       pkArray[kIdx] = tmpArray[tIdx];
 412       tIdx--; kIdx++;
 413    }
 414    ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 25, mBuf);
 415 #endif
 416
 417
 418 #if (ERRCLASS & ERRCLS_ADD_RES)
 419    if (ret != ROK)
 420       SSLOGERROR(ERRCLS_ADD_RES, ESS249, (ErrVal)ret, "SAddPreMsgMult() failed");
 421 #endif
 422    return (ret);
 423
 424 } /* end of SPkF64 */
 425 #endif /* SS_FLOAT */
 426 \f
 427 /*
 428 *
 429 *       Fun:   SUnpkS8
 430 *
 431 *       Desc:  This function unpacks a signed 8 bit value from a message.
 432 *
 433 *       Ret:   ROK      - ok
 434 *
 435 *       Notes: None
 436 *
 437 *       File:  ss_pack.c
 438 *
 439 */
 440
 441 S16 SUnpkS8
 442 (
 443 S8 *val,                    /* pointer to value */
 444 Buffer *mBuf                /* message buffer */
 445 )
 446 {
 447    Data tmp;                /* temporary value */
 448    S16 ret;                 /* return code */
 449
 450 /* ss021.103 - Addition of data pointer check */
 451 #if (ERRCLASS & ERRCLS_INT_PAR)
 452    /* check data pointer */
 453    if (!val)
 454    {
 455       SSLOGERROR(ERRCLS_INT_PAR, ESS250, ERRZERO, "SUnpkS8 : Null value");
 456       return RFAILED;
 457    }
 458 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 459
 460    ret = SRemPreMsg(&tmp, mBuf);
 461 #if (ERRCLASS & ERRCLS_DEBUG)
 462    if (ret != ROK)
 463       SSLOGERROR(ERRCLS_DEBUG, ESS251, (ErrVal)ret, "SRemPreMsg() failed");
 464 #endif
 465    *val = (S8) tmp;
 466    return (ret);
 467 } /* end of SUnpkS8 */
 468
 469 \f
 470 /*
 471 *
 472 *       Fun:   oduPackUInt8
 473 *
 474 *       Desc:  This function unpacks an unsigned 8 bit value from a message.
 475 *
 476 *       Ret:   ROK      - ok
 477 *
 478 *       Notes: None
 479 *
 480 *       File:  ss_pack.c
 481 *
 482 */
 483
 484 S16 oduPackUInt8
 485 (
 486 uint8_t *val,                    /* pointer to value */
 487 Buffer *mBuf                /* message buffer */
 488 )
 489 {
 490    Data tmp;                /* temporary value */
 491    S16 ret;                 /* return code */
 492
 493 /* ss021.103 - Addition of data pointer check */
 494 #if (ERRCLASS & ERRCLS_INT_PAR)
 495    /* check data pointer */
 496    if (!val)
 497    {
 498       SSLOGERROR(ERRCLS_INT_PAR, ESS252, ERRZERO, "oduPackUInt8 : Null value");
 499       return RFAILED;
 500    }
 501 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 502
 503    ret = SRemPreMsg(&tmp, mBuf);
 504 #if (ERRCLASS & ERRCLS_DEBUG)
 505    if (ret != ROK)
 506       SSLOGERROR(ERRCLS_DEBUG, ESS253, (ErrVal)ret, "SRemPreMsg() failed");
 507 #endif
 508    *val = (uint8_t) tmp;
 509    return (ret);
 510 } /* end of oduPackUInt8 */
 511 \f
 512 /*
 513 *
 514 *       Fun:   SUnpkS16
 515 *
 516 *       Desc:  This function unpacks a signed 16 bit value from a message.
 517 *
 518 *       Ret:   ROK      - ok
 519 *
 520 *       Notes: None
 521 *
 522 *       File:  ss_pack.c
 523 *
 524 */
 525
 526 S16 SUnpkS16
 527 (
 528 S16 *val,                   /* pointer to value */
 529 Buffer *mBuf                /* message buffer */
 530 )
 531 {
 532    uint16_t tmp16;               /* temporary value */
 533    Data unpkArray[2];       /* unpacking array */
 534    S16 ret;                 /* return code */
 535
 536 /* ss021.103 - Addition of data pointer check */
 537 #if (ERRCLASS & ERRCLS_INT_PAR)
 538    /* check data pointer */
 539    if (!val)
 540    {
 541       SSLOGERROR(ERRCLS_INT_PAR, ESS254, ERRZERO, "SUnpkS16 : Null value");
 542       return RFAILED;
 543    }
 544 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 545
 546    ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
 547 #if (ERRCLASS & ERRCLS_DEBUG)
 548    if (ret != ROK)
 549       SSLOGERROR(ERRCLS_DEBUG, ESS255, (ErrVal)ret, "SRemPreMsgMult() failed");
 550 #endif
 551    tmp16 = 0;
 552 #ifndef FCSPKINT            /* backward compatibility, packing order */
 553    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
 554    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
 555 #else                       /* forward compatibility, packing order */
 556    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
 557    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
 558 #endif
 559    *val = (S16) tmp16;
 560    return (ret);
 561 } /* end of SUnpkS16 */
 562
 563 \f
 564 /*
 565 *
 566 *       Fun:   oduPackUInt16
 567 *
 568 *       Desc:  This function unpacks an unsigned 16 bit value from a message.
 569 *
 570 *       Ret:   ROK      - ok
 571 *
 572 *       Notes: None
 573 *
 574 *       File:  ss_pack.c
 575 *
 576 */
 577
 578 S16 oduPackUInt16
 579 (
 580 uint16_t *val,                   /* pointer to value */
 581 Buffer *mBuf                /* message buffer */
 582 )
 583 {
 584    uint16_t tmp16;               /* temporary value */
 585    Data unpkArray[2];       /* unpacking array */
 586    S16 ret;                 /* return code */
 587
 588 /* ss021.103 - Addition of data pointer check */
 589 #if (ERRCLASS & ERRCLS_INT_PAR)
 590    /* check data pointer */
 591    if (!val)
 592    {
 593       SSLOGERROR(ERRCLS_INT_PAR, ESS256, ERRZERO, "oduPackUInt16 : Null value");
 594       return RFAILED;
 595    }
 596 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 597
 598    ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
 599 #if (ERRCLASS & ERRCLS_DEBUG)
 600    if (ret != ROK)
 601       SSLOGERROR(ERRCLS_DEBUG, ESS257, (ErrVal)ret, "SRemPreMsgMult failed");
 602 #endif
 603    tmp16 = 0;
 604 #ifndef FCSPKINT            /* backward compatibility, packing order */
 605    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
 606    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
 607 #else                       /* forward compatibility, packing order */
 608    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
 609    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
 610 #endif
 611    *val = tmp16;
 612    return (ret);
 613 } /* end of oduPackUInt16 */
 614
 615 \f
 616 /*
 617 *
 618 *       Fun:   SUnpkS32
 619 *
 620 *       Desc:  This function unpacks a signed 32 bit value from a message.
 621 *
 622 *       Ret:   ROK      - ok
 623 *
 624 *       Notes: None
 625 *
 626 *       File:  ss_pack.c
 627 *
 628 */
 629
 630 S16 SUnpkS32
 631 (
 632 S32 *val,                   /* pointer to value */
 633 Buffer *mBuf                /* message buffer */
 634 )
 635 {
 636    uint16_t tmp16;               /* temporary value */
 637    uint32_t tmp32;               /* temporary value */
 638    Data unpkArray[4];       /* unpacking array */
 639    S16 ret;                 /* return code */
 640
 641 /* ss021.103 - Addition of data pointer check */
 642 #if (ERRCLASS & ERRCLS_INT_PAR)
 643    /* check data pointer */
 644    if (!val)
 645    {
 646       SSLOGERROR(ERRCLS_INT_PAR, ESS258, ERRZERO, "SUnpkS32 : Null value");
 647       return RFAILED;
 648    }
 649 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 650
 651    ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
 652 #if (ERRCLASS & ERRCLS_DEBUG)
 653    if (ret != ROK)
 654       SSLOGERROR(ERRCLS_DEBUG, ESS259, (ErrVal)ret, "SRemPreMsgMult() failed");
 655 #endif
 656    tmp16 = 0;
 657    tmp32 = 0;
 658 #ifndef FCSPKINT            /* backward compatibility, packing order */
 659    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
 660    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
 661    tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
 662    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
 663    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
 664    tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
 665 #else                       /* forward compatibility, packing order */
 666    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
 667    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
 668    tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
 669    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
 670    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
 671    tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
 672 #endif
 673    *val = (S32) tmp32;
 674    return (ret);
 675 } /* end of SUnpkS32 */
 676
 677 \f
 678 /*
 679 *
 680 *       Fun:   oduPackUInt32
 681 *
 682 *       Desc:  This function unpacks an unsigned 32 bit value from a message.
 683 *
 684 *       Ret:   ROK      - ok
 685 *
 686 *       Notes: None
 687 *
 688 *       File:  ss_pack.c
 689 *
 690 */
 691
 692 S16 oduPackUInt32
 693 (
 694 uint32_t *val,                   /* pointer to value */
 695 Buffer *mBuf                /* message buffer */
 696 )
 697 {
 698    uint16_t tmp16;               /* temporary value */
 699    uint32_t tmp32;               /* temporary value */
 700    Data unpkArray[4];       /* unpacking array */
 701 #ifdef ERRCLASS
 702    S16 ret;                 /* return code */
 703 #endif /* ERRCLASS */
 704
 705 /* ss021.103 - Addition of data pointer check */
 706 #if (ERRCLASS & ERRCLS_INT_PAR)
 707    /* check data pointer */
 708    if (!val)
 709    {
 710       SSLOGERROR(ERRCLS_INT_PAR, ESS260, ERRZERO, "oduPackUInt32 : Null value");
 711       return RFAILED;
 712    }
 713 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 714
 715    ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
 716 #if (ERRCLASS & ERRCLS_DEBUG)
 717    if (ret != ROK)
 718       SSLOGERROR(ERRCLS_DEBUG, ESS261, (ErrVal)ret, "SRemPreMsgMult() failed");
 719 #endif
 720
 721    tmp16 = 0;
 722    tmp32 = 0;
 723 #ifndef FCSPKINT            /* backward compatibility, packing order */
 724    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
 725    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
 726    tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
 727    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
 728    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
 729    tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
 730 #else                       /* forward compatibility, packing order */
 731    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
 732    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
 733    tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
 734    tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
 735    tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
 736    tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
 737 #endif
 738    *val = tmp32;
 739    return (ret);
 740 } /* end of oduPackUInt32 */
 741
 742 /*ss038.103  1. Added Floating point support*/
 743 #ifdef SS_FLOAT
 744 /*
 745 *
 746 *       Fun:   SUnpkF32
 747 *
 748 *       Desc:  This function unpacks an 32 bit ieee-754 format float value from a message.
 749 *
 750 *       Ret:   ROK      - ok
 751 *
 752 *       Notes: None
 753 *
 754 *       File:  ss_pack.c
 755 *
 756 */
 757
 758 S16 SUnpkF32
 759 (
 760 F32 *val,                   /* pointer to value */
 761 Buffer *mBuf                /* message buffer */
 762 )
 763 {
 764    S16 ret;                 /* return code */
 765    S8 tmpArray[15];         /* temporary array */
 766 #ifndef FCSPKINT            /* backward compatibility, packing order */
 767    S32 tIdx = 14;           /* temparory array index */
 768    S32 kIdx = 0;            /* unpacking array index */
 769    S8 unpkArray[15];        /* unpacking array */
 770 #endif /* FCSPKINT */
 771
 772 #if (ERRCLASS & ERRCLS_INT_PAR)
 773    /* check data pointer */
 774    if (!val)
 775    {
 776       SSLOGERROR(ERRCLS_INT_PAR, ESS262, ERRZERO, "SUnpkF32 : Null value");
 777       return RFAILED;
 778    }
 779 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 780
 781    ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
 782 #if (ERRCLASS & ERRCLS_DEBUG)
 783    if (ret != ROK)
 784       SSLOGERROR(ERRCLS_DEBUG, ESS263, (ErrVal)ret, "SRemPreMsgMult() failed");
 785 #endif
 786
 787 #ifndef FCSPKINT            /* backward compatibility, packing order */
 788    while(tIdx >= 0)
 789    {
 790       unpkArray[kIdx] = tmpArray[tIdx];
 791       tIdx--; kIdx++;
 792    }
 793    sscanf(unpkArray, "%f", val);
 794 #else
 795    sscanf(tmpArray, "%f", val);
 796 #endif
 797
 798    return (ret);
 799
 800 } /* end of SUnpkF32 */
 801
 802 /*
 803 *
 804 *       Fun:   SUnpkF64
 805 *
 806 *       Desc:  This function unpacks an 64 bit ieee-754 format float value from a message.
 807 *
 808 *       Ret:   ROK      - ok
 809 *
 810 *       Notes: None
 811 *
 812 *       File:  ss_pack.c
 813 *
 814 */
 815
 816 S16 SUnpkF64
 817 (
 818 F64 *val,                   /* pointer to value */
 819 Buffer *mBuf                /* message buffer */
 820 )
 821 {
 822
 823    S16 ret;                 /* return code */
 824    S8 tmpArray[25];         /* temporary array */
 825 #ifndef FCSPKINT            /* backward compatibility, packing order */
 826    S32 tIdx = 24;           /* temparory array index */
 827    S32 kIdx = 0;            /* unpacking array index */
 828    S8 unpkArray[25];        /* unpacking array */
 829 #endif /* FCSPKINT */
 830
 831 #if (ERRCLASS & ERRCLS_INT_PAR)
 832    /* check data pointer */
 833    if (!val)
 834    {
 835       SSLOGERROR(ERRCLS_INT_PAR, ESS264, ERRZERO, "SUnpkF64 : Null value");
 836       return RFAILED;
 837    }
 838 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 839
 840    ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
 841 #if (ERRCLASS & ERRCLS_DEBUG)
 842    if (ret != ROK)
 843       SSLOGERROR(ERRCLS_DEBUG, ESS265, (ErrVal)ret, "SRemPreMsgMult() failed");
 844 #endif
 845
 846 #ifndef FCSPKINT            /* backward compatibility, packing order */
 847    while(tIdx >= 0)
 848    {
 849       unpkArray[kIdx] = tmpArray[tIdx];
 850       tIdx--; kIdx++;
 851    }
 852    sscanf(unpkArray, "%lf", val);
 853 #else
 854    sscanf(tmpArray, "%lf", val);
 855 #endif
 856
 857    return (ret);
 858
 859 } /* end of SUnpkF64 */
 860 #endif /* SS_FLOAT */
 861 \f
 862 /**********************************************************************
 863          End of file
 864  **********************************************************************/