fix with fapi files
[o-du/l2.git] / 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 #ifdef ANSI
92 PUBLIC S16 SPkS8
93 (
94 S8 val,                     /* value */
95 Buffer *mBuf                /* message buffer */
96 )
97 #else
98 PUBLIC S16 SPkS8(val, mBuf)
99 S8 val;                     /* value */
100 Buffer *mBuf;               /* message buffer */
101 #endif
102 {
103    S16 ret;                 /* return code */
104    TRC1(SPkS8)
105    ret = SAddPreMsg((Data) val, mBuf);
106 #if (ERRCLASS & ERRCLS_ADD_RES)
107    if (ret != ROK)
108       SSLOGERROR(ERRCLS_ADD_RES, ESS242, (ErrVal)ret, "SAddPreMsg() failed");
109 #endif
110    RETVALUE(ret);
111 } /* end of SPkS8 */
112   
113
114 \f  
115 /*
116 *
117 *       Fun:   SPkU8
118 *
119 *       Desc:  This function packs an unsigned 8 bit value into a message.
120 *
121 *       Ret:   ROK      - ok
122 *              RFAILED  - failed, general (optional)
123 *              ROUTRES  - failed, out of resources (optional)
124 *
125 *       Notes: None
126 *
127 *       File:  ss_pack.c
128 *
129 */
130   
131 #ifdef ANSI
132 PUBLIC S16 SPkU8
133 (
134 U8 val,                     /* value */
135 Buffer *mBuf                /* message buffer */
136 )
137 #else
138 PUBLIC S16 SPkU8(val, mBuf)
139 U8 val;                     /* value */
140 Buffer *mBuf;               /* message buffer */
141 #endif
142 {
143    S16 ret;                 /* return code */
144    TRC1(SPkU8)
145    ret = SAddPreMsg((Data) val, mBuf);
146 #if (ERRCLASS & ERRCLS_ADD_RES)
147    if (ret != ROK)
148       SSLOGERROR(ERRCLS_ADD_RES, ESS243, (ErrVal)ret, "SAddPreMsg() failed");
149 #endif
150    RETVALUE(ret);
151 } /* end of SPkU8 */
152 \f  
153 /*
154 *
155 *       Fun:   SPkS16
156 *
157 *       Desc:  This function packs a signed 16 bit value into a message.
158 *
159 *       Ret:   ROK      - ok
160 *              RFAILED  - failed, general (optional)
161 *              ROUTRES  - failed, out of resources (optional)
162 *
163 *       Notes: None
164 *
165 *       File:  ss_pack.c
166 *
167 */
168   
169 #ifdef ANSI
170 PUBLIC S16 SPkS16
171 (
172 S16 val,                    /* value */
173 Buffer *mBuf                /* message buffer */
174 )
175 #else
176 PUBLIC S16 SPkS16(val, mBuf)
177 S16 val;                    /* value */
178 Buffer *mBuf;               /* message buffer */
179 #endif
180 {
181    Data pkArray[2];         /* array for packing */
182    S16 ret;                 /* return code */
183
184    TRC1(SPkS16)
185 #ifndef FCSPKINT            /* backward compatibility, packing order */
186    pkArray[0] = (Data) GetHiByte(val);
187    pkArray[1] = (Data) GetLoByte(val);
188 #else                   /* forward compatibility, packing order */
189    pkArray[1] = (Data) GetHiByte(val);
190    pkArray[0] = (Data) GetLoByte(val);
191 #endif
192    ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
193 #if (ERRCLASS & ERRCLS_ADD_RES)
194    if (ret != ROK)
195       SSLOGERROR(ERRCLS_ADD_RES, ESS244, (ErrVal)ret, "SAddPreMsgMult() failed");
196 #endif
197    RETVALUE(ret);
198 } /* end of SPkS16 */
199   
200 \f  
201 /*
202 *
203 *       Fun:   SPkU16
204 *
205 *       Desc:  This function packs an unsigned 16 bit value into a message.
206 *
207 *       Ret:   ROK      - ok
208 *              RFAILED  - failed, general (optional)
209 *              ROUTRES  - failed, out of resources (optional)
210 *
211 *       Notes: None
212 *
213 *       File:  ss_pack.c
214 *
215 */
216   
217 #ifdef ANSI
218 PUBLIC S16 SPkU16
219 (
220 U16 val,                    /* value */
221 Buffer *mBuf                /* message buffer */
222 )
223 #else
224 PUBLIC S16 SPkU16(val, mBuf)
225 U16 val;                    /* value */
226 Buffer *mBuf;               /* message buffer */
227 #endif
228 {
229    Data pkArray[2];         /* array for packing */
230    S16 ret;                 /* return code */
231
232    TRC1(SPkU16)
233 #ifndef FCSPKINT            /* backward compatibility, packing order */
234    pkArray[0] = (Data) GetHiByte(val);
235    pkArray[1] = (Data) GetLoByte(val);
236 #else                       /* forward compatibility, packing order */
237    pkArray[1] = (Data) GetHiByte(val);
238    pkArray[0] = (Data) GetLoByte(val);
239 #endif
240    ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
241 #if (ERRCLASS & ERRCLS_ADD_RES)
242    if (ret != ROK)
243       SSLOGERROR(ERRCLS_ADD_RES, ESS245, (ErrVal)ret, "SAddPreMsgMult() failed");
244 #endif
245    RETVALUE(ret);
246 } /* end of SPkU16 */
247   
248 \f  
249 /*
250 *
251 *       Fun:   SPkS32
252 *
253 *       Desc:  This function packs a signed 32 bit value into a message.
254 *
255 *       Ret:   ROK      - ok
256 *              RFAILED  - failed, general (optional)
257 *              ROUTRES  - failed, out of resources (optional)
258 *
259 *       Notes: None
260 *
261 *       File:  ss_pack.c
262 *
263 */
264   
265 #ifdef ANSI
266 PUBLIC S16 SPkS32
267 (
268 S32 val,                    /* value */
269 Buffer *mBuf                /* message buffer */
270 )
271 #else
272 PUBLIC S16 SPkS32(val, mBuf)
273 S32 val;                    /* value */
274 Buffer *mBuf;               /* message buffer */
275 #endif
276 {
277    U16 tmp;                 /* temporary value */
278    Data pkArray[4];         /* packing array */
279    S16 ret;                 /* return code */
280   
281    TRC1(SPkS32)
282 #ifndef FCSPKINT        /* backward compatibility, packing order */
283    tmp = (U16) GetHiWord(val);
284    pkArray[0] = (Data) GetHiByte(tmp);
285    pkArray[1] = (Data) GetLoByte(tmp);
286    tmp = (U16) GetLoWord(val);
287    pkArray[2] = (Data) GetHiByte(tmp);
288    pkArray[3] = (Data) GetLoByte(tmp);
289 #else                   /* forward compatibility, packing order */
290    tmp = (U16) GetHiWord(val);
291    pkArray[3] = (Data) GetHiByte(tmp);
292    pkArray[2] = (Data) GetLoByte(tmp);
293    tmp = (U16) GetLoWord(val);
294    pkArray[1] = (Data) GetHiByte(tmp);
295    pkArray[0] = (Data) GetLoByte(tmp);
296 #endif
297    ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
298 #if (ERRCLASS & ERRCLS_ADD_RES)
299    if (ret != ROK)
300       SSLOGERROR(ERRCLS_ADD_RES, ESS246, (ErrVal)ret, "SAddPreMsgMult() failed");
301 #endif
302    RETVALUE(ret);
303 } /* end of SPkS32 */
304   
305 \f  
306 /*
307 *
308 *       Fun:   SPkU32
309 *
310 *       Desc:  This function packs an unsigned 32 bit value into a message.
311 *
312 *       Ret:   ROK      - ok
313 *              RFAILED  - failed, general (optional)
314 *              ROUTRES  - failed, out of resources (optional)
315 *
316 *       Notes: None
317 *
318 *       File:  ss_pack.c
319 *
320 */
321   
322 #ifdef ANSI
323 PUBLIC S16 SPkU32
324 (
325 U32 val,                    /* value */
326 Buffer *mBuf                /* message buffer */
327 )
328 #else
329 PUBLIC S16 SPkU32(val, mBuf)
330 U32 val;                    /* value */
331 Buffer *mBuf;               /* message buffer */
332 #endif
333 {
334    U16 tmp;                 /* temporary value */
335    Data pkArray[4];         /* packing array */
336    S16 ret;                 /* return code */
337   
338    TRC1(SPkU32)
339 #ifndef FCSPKINT        /* backward compatibility, packing order */
340    tmp = (U16) GetHiWord(val);
341    pkArray[0] = (Data) GetHiByte(tmp);
342    pkArray[1] = (Data) GetLoByte(tmp);
343    tmp = (U16) GetLoWord(val);
344    pkArray[2] = (Data) GetHiByte(tmp);
345    pkArray[3] = (Data) GetLoByte(tmp);
346 #else                   /* forward compatibility, packing order */
347    tmp = (U16) GetHiWord(val);
348    pkArray[3] = (Data) GetHiByte(tmp);
349    pkArray[2] = (Data) GetLoByte(tmp);
350    tmp = (U16) GetLoWord(val);
351    pkArray[1] = (Data) GetHiByte(tmp);
352    pkArray[0] = (Data) GetLoByte(tmp);
353 #endif
354    ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
355 #if (ERRCLASS & ERRCLS_ADD_RES)
356    if (ret != ROK)
357       SSLOGERROR(ERRCLS_ADD_RES, ESS247, (ErrVal)ret, "SAddPreMsgMult() failed");
358 #endif
359    RETVALUE(ret);
360 } /* end of SPkU32 */
361
362 /*ss038.103  1. Added Floating point support*/
363 #ifdef SS_FLOAT
364 /*
365 *
366 *       Fun:   SPkF32
367 *
368 *       Desc:  This function packs an 32 bit ieee-754 format float value into a message.
369 *
370 *       Ret:   ROK      - ok
371 *              RFAILED  - failed, general (optional)
372 *              ROUTRES  - failed, out of resources (optional)
373 *
374 *       Notes: None
375 *
376 *       File:  ss_pack.c
377 *
378 */
379   
380 #ifdef ANSI
381 PUBLIC S16 SPkF32
382 (
383 F32 val,                    /* value */
384 Buffer *mBuf                /* message buffer */
385 )
386 #else
387 PUBLIC S16 SPkF32(val, mBuf)
388 F32 val;                    /* value */
389 Buffer *mBuf;               /* message buffer */
390 #endif
391 {
392    S16  ret;                /* return code */
393    S8   tmpArray[15];       /* temporary array */
394 #ifdef FCSPKINT             /* backward compatibility, packing order */
395    S32  tIdx = 14;          /* counters */
396    S32  kIdx = 0;           /* counters */
397    S8   pkArray[15];        /* packing array */
398 #endif /*FCSPKINT*/
399   
400    TRC1(SPkF32)
401
402    sprintf(tmpArray, "%.7e", val);
403
404 #ifndef FCSPKINT            /* backward compatibility, packing order */
405    ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
406 #else
407    while(tIdx >= 0)
408    {
409       pkArray[kIdx] = tmpArray[tIdx];
410       tIdx--; kIdx++;
411    }
412    ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 15, mBuf);
413 #endif
414
415
416 #if (ERRCLASS & ERRCLS_ADD_RES)
417    if (ret != ROK)
418       SSLOGERROR(ERRCLS_ADD_RES, ESS248, (ErrVal)ret, "SAddPreMsgMult() failed");
419 #endif
420    RETVALUE(ret);
421 } /* end of SPkF32 */
422
423 /*
424 *
425 *       Fun:   SPkF64
426 *
427 *       Desc:  This function packs an 64 bit ieee-754 format float value into a message.
428 *
429 *       Ret:   ROK      - ok
430 *              RFAILED  - failed, general (optional)
431 *              ROUTRES  - failed, out of resources (optional)
432 *
433 *       Notes: None
434 *
435 *       File:  ss_pack.c
436 *
437 */
438   
439 #ifdef ANSI
440 PUBLIC S16 SPkF64
441 (
442 F64 val,                    /* value */
443 Buffer *mBuf                /* message buffer */
444 )
445 #else
446 PUBLIC S16 SPkF64(val, mBuf)
447 F64 val;                    /* value */
448 Buffer *mBuf;               /* message buffer */
449 #endif
450 {
451
452    S16  ret;                /* return code */
453    S8   tmpArray[25];       /* temporary array */
454 #ifdef FCSPKINT             /* backward compatibility, packing order */
455    S32  tIdx = 24;          /* counters */
456    S32  kIdx = 0;           /* counters */
457    S8   pkArray[25];        /* packing array */
458 #endif /*FCSPKINT*/
459   
460    TRC1(SPkF64)
461
462    sprintf(tmpArray, "%.16le", val);
463
464 #ifndef FCSPKINT            /* backward compatibility, packing order */
465    ret = SAddPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
466 #else
467    while(tIdx >= 0)
468    {
469       pkArray[kIdx] = tmpArray[tIdx];
470       tIdx--; kIdx++;
471    }
472    ret = SAddPreMsgMult((Data*)pkArray, (MsgLen) 25, mBuf);
473 #endif
474
475
476 #if (ERRCLASS & ERRCLS_ADD_RES)
477    if (ret != ROK)
478       SSLOGERROR(ERRCLS_ADD_RES, ESS249, (ErrVal)ret, "SAddPreMsgMult() failed");
479 #endif
480    RETVALUE(ret);
481
482 } /* end of SPkF64 */
483 #endif /* SS_FLOAT */
484 \f  
485 /*
486 *
487 *       Fun:   SUnpkS8
488 *
489 *       Desc:  This function unpacks a signed 8 bit value from a message.
490 *
491 *       Ret:   ROK      - ok
492 *
493 *       Notes: None
494 *
495 *       File:  ss_pack.c
496 *
497 */
498   
499 #ifdef ANSI
500 PUBLIC S16 SUnpkS8
501 (
502 S8 *val,                    /* pointer to value */
503 Buffer *mBuf                /* message buffer */
504 )
505 #else
506 PUBLIC S16 SUnpkS8(val, mBuf)
507 S8 *val;                    /* pointer to value */
508 Buffer *mBuf;               /* message buffer */
509 #endif
510 {
511    Data tmp;                /* temporary value */
512    S16 ret;                 /* return code */
513    TRC1(SUnpkS8)
514
515 /* ss021.103 - Addition of data pointer check */
516 #if (ERRCLASS & ERRCLS_INT_PAR)
517    /* check data pointer */
518    if (!val)
519    {
520       SSLOGERROR(ERRCLS_INT_PAR, ESS250, ERRZERO, "SUnpkS8 : Null value");
521       RETVALUE(RFAILED);
522    }
523 #endif /* ERRCLASS & ERRCLS_INT_PAR */
524
525    ret = SRemPreMsg(&tmp, mBuf);
526 #if (ERRCLASS & ERRCLS_DEBUG)
527    if (ret != ROK)
528       SSLOGERROR(ERRCLS_DEBUG, ESS251, (ErrVal)ret, "SRemPreMsg() failed");
529 #endif
530    *val = (S8) tmp;
531    RETVALUE(ret);
532 } /* end of SUnpkS8 */
533   
534 \f  
535 /*
536 *
537 *       Fun:   SUnpkU8
538 *
539 *       Desc:  This function unpacks an unsigned 8 bit value from a message.
540 *
541 *       Ret:   ROK      - ok
542 *
543 *       Notes: None
544 *
545 *       File:  ss_pack.c
546 *
547 */
548   
549 #ifdef ANSI
550 PUBLIC S16 SUnpkU8
551 (
552 U8 *val,                    /* pointer to value */
553 Buffer *mBuf                /* message buffer */
554 )
555 #else
556 PUBLIC S16 SUnpkU8(val, mBuf)
557 U8 *val;                    /* pointer to value */
558 Buffer *mBuf;               /* message buffer */
559 #endif
560 {
561    Data tmp;                /* temporary value */
562    S16 ret;                 /* return code */
563    TRC1(SUnpkU8)
564
565 /* ss021.103 - Addition of data pointer check */
566 #if (ERRCLASS & ERRCLS_INT_PAR)
567    /* check data pointer */
568    if (!val)
569    {
570       SSLOGERROR(ERRCLS_INT_PAR, ESS252, ERRZERO, "SUnpkU8 : Null value");
571       RETVALUE(RFAILED);
572    }
573 #endif /* ERRCLASS & ERRCLS_INT_PAR */
574
575    ret = SRemPreMsg(&tmp, mBuf);
576 #if (ERRCLASS & ERRCLS_DEBUG)
577    if (ret != ROK)
578       SSLOGERROR(ERRCLS_DEBUG, ESS253, (ErrVal)ret, "SRemPreMsg() failed");
579 #endif
580    *val = (U8) tmp;
581    RETVALUE(ret);
582 } /* end of SUnpkU8 */
583 \f  
584 /*
585 *
586 *       Fun:   SUnpkS16
587 *
588 *       Desc:  This function unpacks a signed 16 bit value from a message.
589 *
590 *       Ret:   ROK      - ok
591 *
592 *       Notes: None
593 *
594 *       File:  ss_pack.c
595 *
596 */
597   
598 #ifdef ANSI
599 PUBLIC S16 SUnpkS16
600 (
601 S16 *val,                   /* pointer to value */
602 Buffer *mBuf                /* message buffer */
603 )
604 #else
605 PUBLIC S16 SUnpkS16(val, mBuf)
606 S16 *val;                   /* pointer to value */
607 Buffer *mBuf;               /* message buffer */
608 #endif
609 {
610    U16 tmp16;               /* temporary value */
611    Data unpkArray[2];       /* unpacking array */
612    S16 ret;                 /* return code */
613    TRC1(SUnpkS16)
614
615 /* ss021.103 - Addition of data pointer check */
616 #if (ERRCLASS & ERRCLS_INT_PAR)
617    /* check data pointer */
618    if (!val)
619    {
620       SSLOGERROR(ERRCLS_INT_PAR, ESS254, ERRZERO, "SUnpkS16 : Null value");
621       RETVALUE(RFAILED);
622    }
623 #endif /* ERRCLASS & ERRCLS_INT_PAR */
624
625    ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
626 #if (ERRCLASS & ERRCLS_DEBUG)
627    if (ret != ROK)
628       SSLOGERROR(ERRCLS_DEBUG, ESS255, (ErrVal)ret, "SRemPreMsgMult() failed");
629 #endif
630    tmp16 = 0; 
631 #ifndef FCSPKINT            /* backward compatibility, packing order */
632    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
633    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
634 #else                       /* forward compatibility, packing order */
635    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
636    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
637 #endif
638    *val = (S16) tmp16;
639    RETVALUE(ret);
640 } /* end of SUnpkS16 */
641   
642 \f  
643 /*
644 *
645 *       Fun:   SUnpkU16
646 *
647 *       Desc:  This function unpacks an unsigned 16 bit value from a message.
648 *
649 *       Ret:   ROK      - ok
650 *
651 *       Notes: None
652 *
653 *       File:  ss_pack.c
654 *
655 */
656   
657 #ifdef ANSI
658 PUBLIC S16 SUnpkU16
659 (
660 U16 *val,                   /* pointer to value */
661 Buffer *mBuf                /* message buffer */
662 )
663 #else
664 PUBLIC S16 SUnpkU16(val, mBuf)
665 U16 *val;                   /* pointer to value */
666 Buffer *mBuf;               /* message buffer */
667 #endif
668 {
669    U16 tmp16;               /* temporary value */
670    Data unpkArray[2];       /* unpacking array */
671    S16 ret;                 /* return code */
672    TRC1(SUnpkU16)
673
674 /* ss021.103 - Addition of data pointer check */
675 #if (ERRCLASS & ERRCLS_INT_PAR)
676    /* check data pointer */
677    if (!val)
678    {
679       SSLOGERROR(ERRCLS_INT_PAR, ESS256, ERRZERO, "SUnpkU16 : Null value");
680       RETVALUE(RFAILED);
681    }
682 #endif /* ERRCLASS & ERRCLS_INT_PAR */
683
684    ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
685 #if (ERRCLASS & ERRCLS_DEBUG)
686    if (ret != ROK)
687       SSLOGERROR(ERRCLS_DEBUG, ESS257, (ErrVal)ret, "SRemPreMsgMult failed");
688 #endif
689    tmp16 = 0; 
690 #ifndef FCSPKINT            /* backward compatibility, packing order */
691    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
692    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
693 #else                       /* forward compatibility, packing order */
694    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
695    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
696 #endif
697    *val = tmp16;
698    RETVALUE(ret);
699 } /* end of SUnpkU16 */
700   
701 \f  
702 /*
703 *
704 *       Fun:   SUnpkS32
705 *
706 *       Desc:  This function unpacks a signed 32 bit value from a message.
707 *
708 *       Ret:   ROK      - ok
709 *
710 *       Notes: None
711 *
712 *       File:  ss_pack.c
713 *
714 */
715   
716 #ifdef ANSI
717 PUBLIC S16 SUnpkS32
718 (
719 S32 *val,                   /* pointer to value */
720 Buffer *mBuf                /* message buffer */
721 )
722 #else
723 PUBLIC S16 SUnpkS32(val, mBuf)
724 S32 *val;                   /* pointer to value */
725 Buffer *mBuf;               /* message buffer */
726 #endif
727 {
728    U16 tmp16;               /* temporary value */
729    U32 tmp32;               /* temporary value */
730    Data unpkArray[4];       /* unpacking array */
731    S16 ret;                 /* return code */
732    TRC1(SUnpkS32)
733
734 /* ss021.103 - Addition of data pointer check */
735 #if (ERRCLASS & ERRCLS_INT_PAR)
736    /* check data pointer */
737    if (!val)
738    {
739       SSLOGERROR(ERRCLS_INT_PAR, ESS258, ERRZERO, "SUnpkS32 : Null value");
740       RETVALUE(RFAILED);
741    }
742 #endif /* ERRCLASS & ERRCLS_INT_PAR */
743
744    ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
745 #if (ERRCLASS & ERRCLS_DEBUG)
746    if (ret != ROK)
747       SSLOGERROR(ERRCLS_DEBUG, ESS259, (ErrVal)ret, "SRemPreMsgMult() failed");
748 #endif
749    tmp16 = 0;
750    tmp32 = 0; 
751 #ifndef FCSPKINT            /* backward compatibility, packing order */
752    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
753    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
754    tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
755    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
756    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
757    tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
758 #else                       /* forward compatibility, packing order */
759    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
760    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
761    tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
762    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
763    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
764    tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
765 #endif
766    *val = (S32) tmp32;
767    RETVALUE(ret);
768 } /* end of SUnpkS32 */
769   
770 \f  
771 /*
772 *
773 *       Fun:   SUnpkU32
774 *
775 *       Desc:  This function unpacks an unsigned 32 bit value from a message.
776 *
777 *       Ret:   ROK      - ok
778 *
779 *       Notes: None
780 *
781 *       File:  ss_pack.c
782 *
783 */
784   
785 #ifdef ANSI
786 PUBLIC S16 SUnpkU32
787 (
788 U32 *val,                   /* pointer to value */
789 Buffer *mBuf                /* message buffer */
790 )
791 #else
792 PUBLIC S16 SUnpkU32(val, mBuf)
793 U32 *val;                   /* pointer to value */
794 Buffer *mBuf;               /* message buffer */
795 #endif
796 {
797    U16 tmp16;               /* temporary value */
798    U32 tmp32;               /* temporary value */
799    Data unpkArray[4];       /* unpacking array */
800 #ifdef ERRCLASS
801    S16 ret;                 /* return code */
802 #endif /* ERRCLASS */
803    TRC1(SUnpkU32)
804
805 /* ss021.103 - Addition of data pointer check */
806 #if (ERRCLASS & ERRCLS_INT_PAR)
807    /* check data pointer */
808    if (!val)
809    {
810       SSLOGERROR(ERRCLS_INT_PAR, ESS260, ERRZERO, "SUnpkU32 : Null value");
811       RETVALUE(RFAILED);
812    }
813 #endif /* ERRCLASS & ERRCLS_INT_PAR */
814
815    ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
816 #if (ERRCLASS & ERRCLS_DEBUG)
817    if (ret != ROK)
818       SSLOGERROR(ERRCLS_DEBUG, ESS261, (ErrVal)ret, "SRemPreMsgMult() failed");
819 #endif
820
821    tmp16 = 0;
822    tmp32 = 0; 
823 #ifndef FCSPKINT            /* backward compatibility, packing order */
824    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
825    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
826    tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
827    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
828    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
829    tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
830 #else                       /* forward compatibility, packing order */
831    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
832    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
833    tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
834    tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
835    tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
836    tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
837 #endif
838    *val = tmp32;
839    RETVALUE(ret);
840 } /* end of SUnpkU32 */
841
842 /*ss038.103  1. Added Floating point support*/
843 #ifdef SS_FLOAT
844 /*
845 *
846 *       Fun:   SUnpkF32
847 *
848 *       Desc:  This function unpacks an 32 bit ieee-754 format float value from a message.
849 *
850 *       Ret:   ROK      - ok
851 *
852 *       Notes: None
853 *
854 *       File:  ss_pack.c
855 *
856 */
857   
858 #ifdef ANSI
859 PUBLIC S16 SUnpkF32
860 (
861 F32 *val,                   /* pointer to value */
862 Buffer *mBuf                /* message buffer */
863 )
864 #else
865 PUBLIC S16 SUnpkF32(val, mBuf)
866 F32 *val;                   /* pointer to value */
867 Buffer *mBuf;               /* message buffer */
868 #endif
869 {
870    S16 ret;                 /* return code */
871    S8 tmpArray[15];         /* temporary array */
872 #ifndef FCSPKINT            /* backward compatibility, packing order */
873    S32 tIdx = 14;           /* temparory array index */
874    S32 kIdx = 0;            /* unpacking array index */
875    S8 unpkArray[15];        /* unpacking array */
876 #endif /* FCSPKINT */
877
878    TRC1(SUnpkF32)
879
880 #if (ERRCLASS & ERRCLS_INT_PAR)
881    /* check data pointer */
882    if (!val)
883    {
884       SSLOGERROR(ERRCLS_INT_PAR, ESS262, ERRZERO, "SUnpkF32 : Null value");
885       RETVALUE(RFAILED);
886    }
887 #endif /* ERRCLASS & ERRCLS_INT_PAR */
888
889    ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 15, mBuf);
890 #if (ERRCLASS & ERRCLS_DEBUG)
891    if (ret != ROK)
892       SSLOGERROR(ERRCLS_DEBUG, ESS263, (ErrVal)ret, "SRemPreMsgMult() failed");
893 #endif
894
895 #ifndef FCSPKINT            /* backward compatibility, packing order */
896    while(tIdx >= 0)
897    {
898       unpkArray[kIdx] = tmpArray[tIdx];
899       tIdx--; kIdx++;
900    }
901    sscanf(unpkArray, "%f", val);
902 #else
903    sscanf(tmpArray, "%f", val);
904 #endif
905
906    RETVALUE(ret);
907
908 } /* end of SUnpkF32 */
909
910 /*
911 *
912 *       Fun:   SUnpkF64
913 *
914 *       Desc:  This function unpacks an 64 bit ieee-754 format float value from a message.
915 *
916 *       Ret:   ROK      - ok
917 *
918 *       Notes: None
919 *
920 *       File:  ss_pack.c
921 *
922 */
923   
924 #ifdef ANSI
925 PUBLIC S16 SUnpkF64
926 (
927 F64 *val,                   /* pointer to value */
928 Buffer *mBuf                /* message buffer */
929 )
930 #else
931 PUBLIC S16 SUnpkF64(val, mBuf)
932 F64 *val;                   /* pointer to value */
933 Buffer *mBuf;               /* message buffer */
934 #endif
935 {
936
937    S16 ret;                 /* return code */
938    S8 tmpArray[25];         /* temporary array */
939 #ifndef FCSPKINT            /* backward compatibility, packing order */
940    S32 tIdx = 24;           /* temparory array index */
941    S32 kIdx = 0;            /* unpacking array index */
942    S8 unpkArray[25];        /* unpacking array */
943 #endif /* FCSPKINT */
944
945    TRC1(SUnpkF64)
946
947 #if (ERRCLASS & ERRCLS_INT_PAR)
948    /* check data pointer */
949    if (!val)
950    {
951       SSLOGERROR(ERRCLS_INT_PAR, ESS264, ERRZERO, "SUnpkF64 : Null value");
952       RETVALUE(RFAILED);
953    }
954 #endif /* ERRCLASS & ERRCLS_INT_PAR */
955
956    ret = SRemPreMsgMult((Data*)tmpArray, (MsgLen) 25, mBuf);
957 #if (ERRCLASS & ERRCLS_DEBUG)
958    if (ret != ROK)
959       SSLOGERROR(ERRCLS_DEBUG, ESS265, (ErrVal)ret, "SRemPreMsgMult() failed");
960 #endif
961
962 #ifndef FCSPKINT            /* backward compatibility, packing order */
963    while(tIdx >= 0)
964    {
965       unpkArray[kIdx] = tmpArray[tIdx];
966       tIdx--; kIdx++;
967    }
968    sscanf(unpkArray, "%lf", val);
969 #else
970    sscanf(tmpArray, "%lf", val);
971 #endif
972
973    RETVALUE(ret);
974
975 } /* end of SUnpkF64 */
976 #endif /* SS_FLOAT */
977 \f
978 /**********************************************************************
979          End of file
980  **********************************************************************/