Docs and build updates along with prachCfgTableIdx completion
[o-du/l2.git] / src / cm / cm_gen.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
19 \f
20 /********************************************************************20**
21   
22      Name:     common body 6
23   
24      Type:     C source file
25   
26      Desc:     common functions used to pack and unpack primitives and 
27                structures that are:
28
29                - Common to all interfaces e.g. Addrs, etc.
30                  These functions are always compiled.
31
32                All functions pack/unpack assuming that the most significant 
33                bit is towards the head of the buffer.
34
35      File:     cm_gen.c
36   
37 *********************************************************************21*/
38   
39 \f   
40 /* header include files (.h) */
41   
42 #include "envopt.h"        /* environment options */  
43 #include "envdep.h"        /* environment dependent */
44 #include "envind.h"        /* environment independent */
45
46 #include "gen.h"           /* general layer */
47 #include "ssi.h"           /* system services */
48
49 #ifndef CMFILE_REORG_1
50 #include "cm_gen.h"        /* common pack/unpack functions */
51 #endif
52
53 #include "cm_err.h"        /* common error */
54
55 /* header/extern include files (.x) */
56   
57 #include "gen.x"           /* general layer */
58 #include "ssi.x"           /* system services */
59
60 #ifndef CMFILE_REORG_1
61 #include "cm_gen.x"        /* common pack/unpack functions */
62 #endif
63
64 \f  
65 /* local defines */
66   
67 /* local typedefs */
68
69 /* local externs */
70   
71 /* forward references */
72
73 /* functions in other modules */
74
75 /* public variable declarations */
76 U16 gTransId = 0;
77
78 /* private variable declarations */
79
80 \f
81 /* 
82  * common packing functions 
83  */
84
85 \f
86 /*
87 *
88 *       Fun:   cmPkDateTime
89 *
90 *       Desc:  This function packs the Date Time structure
91 *
92 *       Ret:   ROK      - ok
93 *
94 *       Notes: None.
95 *
96 *       File:  cm_gen.c
97 *
98 */
99   
100 #ifdef ANSI
101 PUBLIC S16 cmPkDateTime
102 (
103 DateTime *dateTime,       /* date and time */
104 Buffer *mBuf              /* message buffer */
105 )
106 #else
107 PUBLIC S16 cmPkDateTime(dateTime, mBuf)
108 DateTime *dateTime;       /* date and time */
109 Buffer *mBuf;             /* message buffer */
110 #endif
111 {
112    TRC2(cmPkDateTime)
113
114    /*-- cm_gen_c_001.main_36 - added for micro seconds --*/
115 #ifdef SS_DATETIME_USEC
116    CMCHKPK(SPkU32, dateTime->usec, mBuf);
117 #endif /*-- SS_DATETIME_USEC --*/
118    CMCHKPK(SPkU8, dateTime->tenths, mBuf);
119    CMCHKPK(SPkU8, dateTime->sec, mBuf); 
120    CMCHKPK(SPkU8, dateTime->min, mBuf); 
121    CMCHKPK(SPkU8, dateTime->hour, mBuf);
122    CMCHKPK(SPkU8, dateTime->year, mBuf);
123    CMCHKPK(SPkU8, dateTime->day, mBuf);
124    CMCHKPK(SPkU8, dateTime->month, mBuf);
125
126    RETVALUE(ROK);
127 } /* end of cmPkDateTime */
128
129 \f
130 /*
131 *
132 *       Fun:   cmPkDuration
133 *
134 *       Desc:  This function packs the Duration structure
135 *
136 *       Ret:   ROK      - ok
137 *
138 *       Notes: None.
139 *
140 *       File:  cm_gen.c
141 *
142 */
143   
144 #ifdef ANSI
145 PUBLIC S16 cmPkDuration
146 (
147 Duration *duration,        /* duration */
148 Buffer   *mBuf             /* message buffer */
149 )
150 #else
151 PUBLIC S16 cmPkDuration(duration, mBuf)
152 Duration *duration;        /* duration */
153 Buffer   *mBuf;            /* message buffer */
154 #endif
155 {
156    TRC2(cmPkDuration)
157
158    CMCHKPK(SPkU8, duration->tenths, mBuf);
159    CMCHKPK(SPkU8, duration->secs,   mBuf);
160    CMCHKPK(SPkU8, duration->mins,   mBuf);
161    CMCHKPK(SPkU8, duration->hours,  mBuf);
162    CMCHKPK(SPkU8, duration->days,   mBuf);
163
164    RETVALUE(ROK);
165 } /* end of cmPkDuration */
166
167 /*
168 *
169 *       Fun:   cmPkPtr
170 *
171 *       Desc:  This function packs the pointer
172 *
173 *       Ret:   ROK      - ok
174 *
175 *       Notes: None.
176 *
177 *       File:  cm_gen.c
178 *
179 */
180  
181 #ifdef ANSI
182 PUBLIC S16 cmPkPtr
183 (
184 PTR      ptr,              /* pointer */
185 Buffer   *mBuf             /* message buffer */
186 )
187 #else
188 PUBLIC S16 cmPkPtr(ptr, mBuf)
189 PTR      ptr;              /* pointer */
190 Buffer   *mBuf;            /* message buffer */
191 #endif
192 {
193    Data pkArray[PTRSIZE];   /* array for packing */
194    S16 ret;                 /* return code */
195    U16 tmp;                 /* temporary value */
196
197 #if (defined(ALPHA) || defined(BIT_64))
198    U32 tmp32;
199 #endif
200
201    TRC2(cmPkPtr)
202    
203    ret = ROK;
204    switch (PTRSIZE)
205    {
206       case 2:
207 #ifndef FCSPKINT            /* backward compatibility, packing order */
208          pkArray[0] = (Data) GetHiByte(ptr);
209          pkArray[1] = (Data) GetLoByte(ptr);
210 #else                       /* forward compatibility, packing order */
211          pkArray[1] = (Data) GetHiByte(ptr);
212          pkArray[0] = (Data) GetLoByte(ptr);
213 #endif
214          ret = SAddPreMsgMult(pkArray, (MsgLen) 2, mBuf);
215          break;
216     
217       case 4: 
218 #ifndef FCSPKINT        /* backward compatibility, packing order */
219          tmp = (U16) GetHiWord(ptr);
220          pkArray[0] = (Data) GetHiByte(tmp);
221          pkArray[1] = (Data) GetLoByte(tmp);
222          tmp = (U16) GetLoWord(ptr);
223          pkArray[2] = (Data) GetHiByte(tmp);
224          pkArray[3] = (Data) GetLoByte(tmp);
225 #else                   /* forward compatibility, packing order */
226          tmp = (U16) GetHiWord(ptr);
227          pkArray[3] = (Data) GetHiByte(tmp);
228          pkArray[2] = (Data) GetLoByte(tmp);
229          tmp = (U16) GetLoWord(ptr);
230          pkArray[1] = (Data) GetHiByte(tmp);
231          pkArray[0] = (Data) GetLoByte(tmp);
232 #endif
233          ret = SAddPreMsgMult(pkArray, (MsgLen) 4, mBuf);
234          break;
235
236       case 8:
237 #if (defined(ALPHA) || defined(BIT_64))
238 #ifndef FCSPKINT        /* backward compatibility, packing order */
239          tmp32 = (U32) GetHi32Bit(ptr);
240          tmp = (U16) GetHiWord(tmp32);
241          pkArray[0] = (Data) GetHiByte(tmp);
242          pkArray[1] = (Data) GetLoByte(tmp);
243          tmp = (U16) GetLoWord(tmp32);
244          pkArray[2] = (Data) GetHiByte(tmp);
245          pkArray[3] = (Data) GetLoByte(tmp);
246          tmp32 = (U32) GetLo32Bit(ptr);
247          tmp = (U16) GetHiWord(tmp32);
248          pkArray[4] = (Data) GetHiByte(tmp);
249          pkArray[5] = (Data) GetLoByte(tmp);
250          tmp = (U16) GetLoWord(tmp32);
251          pkArray[6] = (Data) GetHiByte(tmp);
252          pkArray[7] = (Data) GetLoByte(tmp);
253 #else                   /* forward compatibility, packing order */
254          tmp32 = (U32) GetHi32Bit(ptr);
255          tmp = (U16) GetHiWord(tmp32);
256          pkArray[7] = (Data) GetHiByte(tmp);
257          pkArray[6] = (Data) GetLoByte(tmp);
258          tmp = (U16) GetLoWord(tmp32);
259          pkArray[5] = (Data) GetHiByte(tmp);
260          pkArray[4] = (Data) GetLoByte(tmp);
261          tmp32 = (U32) GetLo32Bit(ptr);
262          tmp = (U16) GetHiWord(tmp32);
263          pkArray[3] = (Data) GetHiByte(tmp);
264          pkArray[2] = (Data) GetLoByte(tmp);
265          tmp = (U16) GetLoWord(tmp32);
266          pkArray[1] = (Data) GetHiByte(tmp);
267          pkArray[0] = (Data) GetLoByte(tmp);
268 #endif
269          ret = SAddPreMsgMult(pkArray, (MsgLen) 8, mBuf);
270          break;
271 #endif
272       default:
273          /* no support for U64 */
274          ret = RFAILED;
275    }
276
277    RETVALUE(ret);
278 } /* end of cmPkPtr */
279
280 \f
281 /*
282 *
283 *       Fun:   cmPkEntityId
284 *
285 *       Desc:  This function packs the EntityId structure
286 *
287 *       Ret:   ROK      - ok
288 *
289 *       Notes: None.
290 *
291 *       File:  cm_gen.c
292 *
293 */
294   
295 #ifdef ANSI
296 PUBLIC S16 cmPkEntityId
297 (
298 EntityId *entityId,        /* entity id */
299 Buffer   *mBuf             /* message buffer */
300 )
301 #else
302 PUBLIC S16 cmPkEntityId(entityId, mBuf)
303 EntityId *entityId;        /* entity id */
304 Buffer   *mBuf;            /* message buffer */
305 #endif
306 {
307    TRC2(cmPkEntityId)
308
309    CMCHKPK(cmPkInst, entityId->inst, mBuf);
310    CMCHKPK(cmPkEnt, entityId->ent, mBuf);
311
312    RETVALUE(ROK);
313 } /* end of cmPkEntityId */
314
315 \f
316 /*
317 *
318 *       Fun:   cmPkElmntId
319 *
320 *       Desc:  This function packs the ElmntId structure
321 *
322 *       Ret:   ROK      - ok
323 *
324 *       Notes: None.
325 *
326 *       File:  cm_gen.c
327 *
328 */
329   
330 #ifdef ANSI
331 PUBLIC S16 cmPkElmntId
332 (
333 ElmntId *elmntId,         /* element id */
334 Buffer  *mBuf             /* message buffer */
335 )
336 #else
337 PUBLIC S16 cmPkElmntId(elmntId, mBuf)
338 ElmntId *elmntId;         /* element id */
339 Buffer  *mBuf;            /* message buffer */
340 #endif
341 {
342    TRC2(cmPkElmntId)
343
344    CMCHKPK(cmPkElmntInst3, elmntId->elmntInst3, mBuf); 
345    CMCHKPK(cmPkElmntInst2, elmntId->elmntInst2, mBuf); 
346    CMCHKPK(cmPkElmntInst1, elmntId->elmntInst1, mBuf); 
347    CMCHKPK(cmPkElmnt, elmntId->elmnt, mBuf);
348
349    RETVALUE(ROK);
350 } /* end of cmPkElmntId */
351
352 \f
353 /*
354 *
355 *       Fun:   cmPkMemoryId
356 *
357 *       Desc:  This function packs the MemoryId structure
358 *
359 *       Ret:   ROK      - ok
360 *
361 *       Notes: None.
362 *
363 *       File:  cm_gen.c
364 *
365 */
366   
367 #ifdef ANSI
368 PUBLIC S16 cmPkMemoryId
369 (
370 MemoryId *memoryId,        /* memoryId */
371 Buffer   *mBuf             /* message buffer */
372 )
373 #else
374 PUBLIC S16 cmPkMemoryId(memoryId, mBuf)
375 MemoryId *memoryId;        /* memoryId */
376 Buffer   *mBuf;            /* message buffer */
377 #endif
378 {
379    TRC2(cmPkMemoryId)
380
381    CMCHKPK(cmPkPool, memoryId->pool, mBuf); 
382    CMCHKPK(cmPkRegion, memoryId->region, mBuf);
383
384    RETVALUE(ROK);
385 } /* end of cmPkMemoryId */
386
387 \f
388 /*
389 *
390 *       Fun:   cmPkSystemId
391 *
392 *       Desc:  This function packs the System Id structure
393 *
394 *       Ret:   ROK      - ok
395 *
396 *       Notes: None.
397 *
398 *       File:  cm_gen.c
399 *
400 */
401   
402 #ifdef ANSI
403 PUBLIC S16 cmPkSystemId
404 (
405 SystemId *systemId,         /* system id */
406 Buffer   *mBuf              /* message buffer */
407 )
408 #else
409 PUBLIC S16 cmPkSystemId(systemId, mBuf)
410 SystemId *systemId;         /* system id */
411 Buffer   *mBuf;             /* message buffer */
412 #endif
413 {
414    Txt *p;                  /* part number string */
415
416    TRC2(cmPkSystemId)
417
418    for (p = systemId->ptNmb; *p; p++);
419
420    for (; p != systemId->ptNmb; p--)
421    {
422       CMCHKPK(cmPkTxt, *p, mBuf);
423    }
424    CMCHKPK(cmPkTxt, *p, mBuf);
425    
426    CMCHKPK(SPkS16, systemId->bRev, mBuf);
427    CMCHKPK(SPkS16, systemId->bVer, mBuf);
428    CMCHKPK(SPkS16, systemId->mRev, mBuf);
429    CMCHKPK(SPkS16, systemId->mVer, mBuf);
430
431    RETVALUE(ROK);
432 } /* end of cmPkSystemId */
433
434
435
436 /*
437  *
438  *       Fun:   cmPkProtAddr
439  *
440  *       Desc:  This function will pack protocol address.
441  *
442  *       Ret:   ROK on success
443  *              RFAILED on error
444  *
445  *       Notes: None
446  *
447          File:  cm_gen.c
448  *
449  */
450
451 #ifdef ANSI
452 PUBLIC S16 cmPkProtAddr
453 (
454 ProtAddr     *pAddr,     /* protocol address */
455 Buffer       *mBuf       /* buffer */
456 )
457 #else
458 PUBLIC S16 cmPkProtAddr(pAddr, mBuf)
459 ProtAddr     *pAddr;      /* protocol address */
460 Buffer       *mBuf;          /* buffer */
461 #endif
462 {
463    U8              j;                  /* Index */
464
465    TRC3(cmPkProtAddr)
466
467 #ifdef CM_ARI2
468    CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);  
469    CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);  
470 #endif /* CM_ARI2 */
471
472    for (j = pAddr->len; j; j--)
473       CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);  
474
475    CMCHKPK(SPkU8,  pAddr->preLen, mBuf);  
476    CMCHKPK(SPkU8,  pAddr->len, mBuf);  
477    CMCHKPK(SPkU16, pAddr->protType, mBuf);  
478        
479    RETVALUE(ROK);
480
481 } /* end of cmPkProtAddr */
482    
483
484
485 /*
486  *
487  *       Fun:   cmPkProtAddrTbl
488  *
489  *       Desc:  This function will pack protocol addresses.
490  *
491  *       Ret:   ROK on success
492  *              RFAILED on error
493  *
494  *       Notes: None
495  *
496          File:  cm_gen.c
497  *
498  */
499
500 #ifdef ANSI
501 PUBLIC S16 cmPkProtAddrTbl
502 (
503 ProtAddrTbl  *protAddr,      /* protocol address table */
504 Buffer       *mBuf          /* buffer */
505 )
506 #else
507 PUBLIC S16 cmPkProtAddrTbl(protAddr, mBuf)
508 ProtAddrTbl  *protAddr;      /* protocol address table */
509 Buffer       *mBuf;          /* buffer */
510 #endif
511 {
512    U8              i;                  /* index */
513    U8              j;                  /* Index */
514    ProtAddr        *pAddr;             /* protocol Address */
515
516    TRC3(cmPkProtAddrTbl)
517
518    if (protAddr->count > MAX_PROT_ADDRS)
519       RETVALUE(RFAILED);
520
521    for (i = protAddr->count; i; i--)
522    {
523        pAddr = &(protAddr->addr[i - 1]);
524
525 #ifdef CM_ARI2
526        CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);  
527        CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);  
528 #endif /* CM_ARI2 */
529
530        for (j = pAddr->len; j; j--)
531           CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);  
532         
533        CMCHKPK(SPkU8, pAddr->preLen, mBuf);  
534        CMCHKPK(SPkU8,  pAddr->len, mBuf);  
535        CMCHKPK(SPkU16,  pAddr->protType, mBuf);  
536        
537    }
538    CMCHKPK(SPkU8, protAddr->count, mBuf);  
539
540    RETVALUE(ROK);
541 } /* end of cmPkProtAddrTbl */
542    
543
544 /*
545 *
546 *       Fun:   cmPkAddrs
547 *
548 *       Desc:  This function packs the address structure for a loosely 
549 *              coupled interface
550 *
551 *       Ret:   ROK      - ok
552 *
553 *       Notes: None.
554 *
555 *       File:  cm_gen.c
556 *
557 */
558   
559 #ifdef ANSI
560 PUBLIC S16 cmPkAddrs
561 (
562 Addrs *addrs,           /* address */
563 Buffer *mBuf            /* message buffer */
564 )
565 #else
566 PUBLIC S16 cmPkAddrs(addrs, mBuf)
567 Addrs *addrs;           /* address */
568 Buffer *mBuf;           /* message buffer */
569 #endif
570 {
571    U8 i;                /* loop counter */
572
573    TRC2(cmPkAddrs)
574
575    if (addrs->length > ADRLEN)
576       RETVALUE(RFAILED);
577
578    for (i = addrs->length; i; i--)
579    {
580       CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
581    }
582
583    CMCHKPK(SPkU8, addrs->length, mBuf);
584
585    RETVALUE(ROK);
586 } /* end of cmPkAddrs */
587
588 \f
589 /*
590 *
591 *       Fun:   cmPkShrtAddrs
592 *
593 *       Desc:  This function packs the short address structure for a loosely 
594 *              coupled interface
595 *
596 *       Ret:   ROK      - ok
597 *
598 *       Notes: None.
599 *
600 *       File:  cm_gen.c
601 *
602 */
603   
604 #ifdef ANSI
605 PUBLIC S16 cmPkShrtAddrs
606 (
607 ShrtAddrs *addrs,          /* address */
608 Buffer    *mBuf            /* message buffer */
609 )
610 #else
611 PUBLIC S16 cmPkShrtAddrs(addrs, mBuf)
612 ShrtAddrs *addrs;          /* address */
613 Buffer    *mBuf;           /* message buffer */
614 #endif 
615 {
616    U8 i;                /* loop counter */
617
618    TRC2(cmPkShrtAddrs)
619
620    if (addrs->length > SHRTADRLEN)
621       RETVALUE(RFAILED);
622
623    for (i = addrs->length; i; i--)
624    {
625       CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
626    }
627
628    CMCHKPK(SPkU8, addrs->length, mBuf);
629
630    RETVALUE(ROK);
631 } /* end of cmPkShrtAddrs */
632
633 \f
634 /*
635 *
636 *       Fun:   cmPkAddrMask
637 *
638 *       Desc:  This function address mask array.
639 *
640 *       Ret:   ROK      - ok
641 *
642 *       Notes: None
643 *
644 *       File:  cm_gen.c
645 *
646 */
647   
648 #ifdef ANSI
649 PUBLIC S16 cmPkAddrMask
650 (
651 U8 *mask,             /* pointer to address mask array */
652 Buffer  *mBuf         /* message buffer */
653 )
654 #else
655 PUBLIC S16 cmPkAddrMask(mask, mBuf)
656 U8 *mask;             /* pointer to address mask array */
657 Buffer  *mBuf;        /* message buffer */
658 #endif
659 {
660    S16 i;             /* counter */
661
662    TRC2(cmPkAddrMask)
663
664    /* pack address mask */
665    for (i = (ADRLEN - 1); i >= 0; i--)
666    {
667       CMCHKPK(SPkU8, mask[i], mBuf);
668    }
669
670    RETVALUE(ROK);
671 } /* end of cmPkAddrMask */
672
673 \f
674 /*
675 *
676 *       Fun:   cmPkBndCfg
677 *
678 *       Desc:  This function packs the BndCfg structure
679 *
680 *       Ret:   ROK      - ok
681 *
682 *       Notes: None.
683 *
684 *       File:  cm_gen.c
685 *
686 */
687   
688 #ifdef ANSI
689 PUBLIC S16 cmPkBndCfg
690 (
691 BndCfg *bndCfg,         /* bndCfg */
692 Buffer *mBuf            /* message buffer */
693 )
694 #else
695 PUBLIC S16 cmPkBndCfg(bndCfg, mBuf)
696 BndCfg *bndCfg;         /* bndCfg */
697 Buffer *mBuf;           /* message buffer */
698 #endif
699 {
700    Txt *p;              /* temporary */
701
702    TRC2(cmPkBndCfg)
703
704    CMCHKPK(cmPkSelector, bndCfg->selector, mBuf);
705    CMCHKPK(cmPkAddrs, &bndCfg->sapAdr, mBuf);
706    CMCHKPK(cmPkRoute, bndCfg->route, mBuf);
707    CMCHKPK(cmPkPrior, bndCfg->prior, mBuf);
708    CMCHKPK(cmPkPool, bndCfg->pool, mBuf); 
709    CMCHKPK(cmPkRegion, bndCfg->region, mBuf);
710    CMCHKPK(cmPkInst, bndCfg->inst, mBuf);
711    CMCHKPK(cmPkEnt, bndCfg->ent, mBuf);
712    CMCHKPK(SPkU8, bndCfg->wdw, mBuf);
713    CMCHKPK(SPkU8, bndCfg->flcTyp, mBuf);
714    CMCHKPK(SPkU8, bndCfg->bufOwnshp, mBuf);
715
716    for (p = bndCfg->usrId; *p; p++);
717    for (; p != bndCfg->usrId; p--);
718    CMCHKPK(cmPkTxt, *p, mBuf);
719
720    RETVALUE(ROK);
721 } /* end of cmPkBndCfg */
722
723 \f
724 /*
725 *
726 *       Fun:   cmPkPst
727 *
728 *       Desc:  pack post structure 
729 *
730 *       Ret:   ROK
731 *
732 *       Notes: None.
733 *
734 *       File:  cm_gen.c
735 *
736 */
737 #ifdef ANSI
738 PUBLIC S16 cmPkPst
739 (
740 Pst *pst,
741 Buffer *mBuf
742 )
743 #else
744 PUBLIC S16 cmPkPst(pst, mBuf)
745 Pst *pst;
746 Buffer *mBuf;
747 #endif
748 {
749    TRC2(cmPkPst)
750    
751    CMCHKPK(cmPkEvent, pst->event, mBuf);
752    CMCHKPK(cmPkInst, pst->srcInst, mBuf);
753    CMCHKPK(cmPkEnt, pst->srcEnt, mBuf); 
754    CMCHKPK(cmPkProcId, pst->srcProcId, mBuf);
755    CMCHKPK(cmPkInst, pst->dstInst, mBuf); 
756    CMCHKPK(cmPkEnt, pst->dstEnt, mBuf); 
757    CMCHKPK(cmPkProcId, pst->dstProcId, mBuf);
758    CMCHKPK(cmPkRoute, pst->route, mBuf);
759    CMCHKPK(cmPkPrior, pst->prior, mBuf);
760    CMCHKPK(cmPkPool, pst->pool, mBuf);
761    CMCHKPK(cmPkRegion, pst->region, mBuf);
762    CMCHKPK(cmPkSelector, pst->selector, mBuf);
763 #ifdef TDS_ROLL_UPGRADE_SUPPORT
764    CMCHKPK(cmPkIntfVer, pst->intfVer, mBuf);
765 #endif
766
767    RETVALUE(ROK);
768 } /* end of cmPkPst */
769
770 /*
771  *
772  *      Fun:    cmPkElmtHdr
773  *
774  *      Desc:   Pack element header
775  *
776  *      Ret:   ROK      - ok
777  *
778  *      Notes:  None
779  *
780         File:   cm_gen.c
781  *
782  */
783   
784 #ifdef ANSI
785 PUBLIC S16 cmPkElmtHdr
786 (
787 ElmtHdr *m,                  /* element header */
788 Buffer  *mBuf                /* message buffer */
789 )
790 #else
791 PUBLIC S16 cmPkElmtHdr(m, mBuf)
792 ElmtHdr *m;                  /* element header */
793 Buffer  *mBuf;               /* message buffer */
794 #endif
795 {
796    TRC2(cmPkElmtHdr)
797  
798 #if (LCAMT || ATM_BISUP)
799       CMCHKPK(SPkU16, m->compInd, mBuf);
800 #endif /* LCAMT || ATM_BISUP */
801
802 #if (LCAMT || ATM_BISUP)
803    /* Pack action indicator field */
804    if (m->pres)
805    {
806      CMCHKPK(SPkU8, m->actnInd, mBuf);
807    }
808 #endif
809
810    /* Present */
811    CMCHKPK(cmPkBool, m->pres, mBuf);
812
813    RETVALUE(ROK);
814 } /* end of cmPkElmtHdr */
815
816 \f
817 /*
818  *
819  *      Fun:   cmPkTknU8
820  *
821  *      Desc:  This function packs a token U8
822  *
823  *      Ret:   ROK      - ok
824  *
825  *      Notes: None
826  *
827         File:  cm_gen.c
828  *
829  */
830   
831 #ifdef ANSI
832 PUBLIC S16 cmPkTknU8
833 (
834 TknU8  *tknU8,              /* token U8 */
835 Buffer *mBuf                /* message buffer */
836 )
837 #else
838 PUBLIC S16 cmPkTknU8(tknU8, mBuf)
839 TknU8  *tknU8;              /* token U8 */
840 Buffer *mBuf;               /* message buffer */
841 #endif
842 {
843    TRC2(cmPkTknU8)
844
845    if (tknU8->pres)
846    {
847       /* Value */
848       CMCHKPK(SPkU8, tknU8->val, mBuf);
849    }
850
851    /* Token Header */
852    CMCHKPK(SPkU8, tknU8->pres, mBuf);
853
854    RETVALUE(ROK);
855 } /* end of cmPkTknU8 */
856
857 \f
858 /*
859  *
860  *      Fun:   cmPkTknS8
861  *
862  *      Desc:  This function packs a token S8
863  *
864  *      Ret:   ROK      - ok
865  *
866  *      Notes: None
867  *
868         File:  cm_gen.c
869  *
870  */
871   
872 #ifdef ANSI
873 PUBLIC S16 cmPkTknS8
874 (
875 TknS8  *tknS8,              /* token S8 */
876 Buffer *mBuf                /* message buffer */
877 )
878 #else
879 PUBLIC S16 cmPkTknS8(tknS8, mBuf)
880 TknS8  *tknS8;              /* token S8 */
881 Buffer *mBuf;               /* message buffer */
882 #endif
883 {
884    TRC2(cmPkTknS8)
885  
886    if (tknS8->pres)
887    {
888       /* Value */
889       CMCHKPK(SPkS8, tknS8->val, mBuf);
890    }
891  
892    /* Token Header */
893    CMCHKPK(SPkU8, tknS8->pres, mBuf);
894  
895    RETVALUE(ROK);
896 } /* end of cmPkTknS8 */
897
898 \f
899 /*
900  *
901  *      Fun:   cmPkTknU16
902  *
903  *      Desc:  This function packs a token U16
904  *
905  *      Ret:   ROK      - ok
906  *
907  *      Notes: None
908  *
909         File:  cm_gen.c
910  *
911  */
912   
913 #ifdef ANSI
914 PUBLIC S16 cmPkTknU16
915 (
916 TknU16 *tknU16,             /* token U16 */
917 Buffer *mBuf                /* message buffer */
918 )
919 #else
920 PUBLIC S16 cmPkTknU16(tknU16, mBuf)
921 TknU16 *tknU16;             /* token U16 */
922 Buffer *mBuf;               /* message buffer */
923 #endif
924 {
925    TRC2(cmPkTknU16)
926
927    if (tknU16->pres)
928    {
929       /* Value */
930       CMCHKPK(SPkU16, tknU16->val, mBuf);
931    }
932
933    /* Token Header */
934    CMCHKPK(SPkU8, tknU16->pres, mBuf);
935
936    RETVALUE(ROK);
937 } /* end of cmPkTknU16 */
938
939 \f
940 /*
941  *
942  *      Fun:   cmPkTknU32
943  *
944  *      Desc:  This function packs a token U32
945  *
946  *      Ret:   ROK      - ok
947  *
948  *      Notes: None
949  *
950         File:  cm_gen.c
951  *
952  */
953   
954 #ifdef ANSI
955 PUBLIC S16 cmPkTknU32
956 (
957 TknU32 *tknU32,             /* token U32 */
958 Buffer *mBuf                /* message buffer */
959 )
960 #else
961 PUBLIC S16 cmPkTknU32(tknU32, mBuf)
962 TknU32 *tknU32;             /* token U32 */
963 Buffer *mBuf;               /* message buffer */
964 #endif
965 {
966    TRC2(cmPkTknU32)
967
968    if (tknU32->pres)
969    {
970       /* Value */
971       CMCHKPK(SPkU32, tknU32->val, mBuf);
972    }
973
974    /* Token Header */
975    CMCHKPK(SPkU8, tknU32->pres, mBuf);
976
977    RETVALUE(ROK);
978 } /* end of cmPkTknU32 */
979
980 \f
981 /*
982  *
983  *      Fun:   cmPkTknStr
984  *
985  *      Desc:  This function packs a token string - regular size
986  *
987  *      Ret:   ROK      - ok
988  *
989  *      Notes: None
990  *
991         File:  cm_gen.c
992  *
993  */
994   
995 #ifdef ANSI
996 PUBLIC S16 cmPkTknStr
997 (
998 TknStr *tknStr,             /* token string */
999 Buffer *mBuf                /* message buffer */
1000 )
1001 #else
1002 PUBLIC S16 cmPkTknStr(tknStr, mBuf)
1003 TknStr *tknStr;             /* token string */
1004 Buffer *mBuf;               /* message buffer */
1005 #endif
1006 {
1007    Cntr i;                    /* counter */
1008
1009    TRC2(cmPkTknStr)
1010
1011    if (tknStr->pres)
1012    {
1013       /* Value */
1014       for (i = 0; i < (S16) tknStr->len; i++)
1015       {
1016          CMCHKPK(SPkU8, tknStr->val[i], mBuf);
1017       }
1018
1019       /* Length */
1020       CMCHKPK(SPkU8, tknStr->len, mBuf);
1021    }
1022  
1023    /* Token Header */
1024    CMCHKPK(SPkU8, tknStr->pres, mBuf);
1025
1026    RETVALUE(ROK);
1027 } /* end of cmPkTknStr */
1028
1029 \f
1030 /*
1031  *
1032  *      Fun:   cmPkTknStrM
1033  *
1034  *      Desc:  This function packs a token string - medium size
1035  *
1036  *      Ret:   ROK      - ok
1037  *
1038  *      Notes: None
1039  *
1040         File:  cm_gen.c
1041  *
1042  */
1043   
1044 #ifdef ANSI
1045 PUBLIC S16 cmPkTknStrM
1046 (
1047 TknStrM *tknStr,             /* token string */
1048 Buffer *mBuf                /* message buffer */
1049 )
1050 #else
1051 PUBLIC S16 cmPkTknStrM(tknStr, mBuf)
1052 TknStrM *tknStr;             /* token string */
1053 Buffer *mBuf;               /* message buffer */
1054 #endif
1055 {
1056    Cntr i;                    /* counter */
1057
1058    TRC2(cmPkTknStrM)
1059
1060    if(tknStr->pres)
1061    {
1062       /* Value */
1063       for (i = 0; i < (S16) tknStr->len; i++)
1064       {
1065          CMCHKPK(SPkU8, tknStr->val[i], mBuf);
1066       }
1067
1068       /* Length */
1069       CMCHKPK(SPkU8, tknStr->len, mBuf);
1070    }
1071  
1072    /* Token Header */
1073    CMCHKPK(SPkU8, tknStr->pres, mBuf);
1074
1075    RETVALUE(ROK);
1076 } /* end of cmPkTknStrM */
1077
1078 \f
1079 /*
1080  *
1081  *      Fun:   cmPkTknStrS
1082  *
1083  *      Desc:  This function packs a token string - small size
1084  *
1085  *      Ret:   ROK      - ok
1086  *
1087  *      Notes: None
1088  *
1089         File:  cm_gen.c
1090  *
1091  */
1092   
1093 #ifdef ANSI
1094 PUBLIC S16 cmPkTknStrS
1095 (
1096 TknStrS *tknStr,             /* token string */
1097 Buffer *mBuf                /* message buffer */
1098 )
1099 #else
1100 PUBLIC S16 cmPkTknStrS(tknStr, mBuf)
1101 TknStrS *tknStr;             /* token string */
1102 Buffer *mBuf;               /* message buffer */
1103 #endif
1104 {
1105    Cntr i;                    /* counter */
1106
1107    TRC2(cmPkTknStrS)
1108
1109    if(tknStr->pres)
1110    {
1111       /* Value */
1112       for (i = 0; i < (S16) tknStr->len; i++)
1113       {
1114          CMCHKPK(SPkU8, tknStr->val[i], mBuf);
1115       }
1116
1117       /* Length */
1118       CMCHKPK(SPkU8, tknStr->len, mBuf);
1119    }
1120  
1121    /* Token Header */
1122    CMCHKPK(SPkU8, tknStr->pres, mBuf);
1123
1124    RETVALUE(ROK);
1125 } /* end of cmPkTknStrS */
1126
1127 \f
1128 /*
1129  *
1130  *      Fun:   cmPkTknStrE
1131  *
1132  *      Desc:  This function packs a token string - extended size
1133  *
1134  *      Ret:   ROK      - ok
1135  *
1136  *      Notes: None
1137  *
1138         File:  cm_gen.c
1139  *
1140  */
1141   
1142 #ifdef ANSI
1143 PUBLIC S16 cmPkTknStrE
1144 (
1145 TknStrE *tknStr,             /* token string */
1146 Buffer *mBuf                /* message buffer */
1147 )
1148 #else
1149 PUBLIC S16 cmPkTknStrE(tknStr, mBuf)
1150 TknStrE *tknStr;             /* token string */
1151 Buffer *mBuf;               /* message buffer */
1152 #endif
1153 {
1154    Cntr i;                    /* counter */
1155
1156    TRC2(cmPkTknStrE)
1157
1158    if(tknStr->pres)
1159    {
1160       /* Value */
1161       for (i = 0; i < (S16) tknStr->len; i++)
1162       {
1163          CMCHKPK(SPkU8, tknStr->val[i], mBuf);
1164       }
1165
1166       /* Length */
1167       CMCHKPK(SPkU8, tknStr->len, mBuf);
1168    }
1169  
1170    /* Token Header */
1171    CMCHKPK(SPkU8, tknStr->pres, mBuf);
1172
1173    RETVALUE(ROK);
1174 } /* end of cmPkTknStrE */
1175
1176 #ifndef CMFILE_REORG_1
1177
1178 \f
1179 /*
1180 *
1181 *       Fun:   cmPkPnNodeId
1182 *
1183 *       Desc:  This function packs a PnNodeId structure into a buffer
1184 *
1185 *       Ret:   Void
1186 *
1187 *       Notes: None
1188 *
1189 *       File:  cm_gen.c
1190 *
1191 */
1192   
1193 #ifdef ANSI
1194 PUBLIC S16 cmPkPnNodeId
1195 (
1196 PnNodeId  *src,     /* source PNNI Node Id */
1197 Buffer *mBuf        /* message buffer */
1198 )
1199 #else
1200 PUBLIC S16 cmPkPnNodeId (src, mBuf)
1201 PnNodeId  *src;     /* source PNNI Node Id */
1202 Buffer *mBuf;       /* message buffer */
1203 #endif
1204 {
1205    S16 i;
1206    
1207    TRC3(cmPkPnNodeId);
1208    
1209    for (i = PN_NODEID_LEN - 1; i >= 0; i--)
1210    {
1211       CMCHKPK(SPkU8, src->id[i], mBuf);
1212    }
1213    
1214    RETVALUE(ROK);
1215 } /* cmPkPnNodeId */
1216
1217 #endif /* CMFILE_REORG_1 */
1218
1219 \f
1220 /*
1221  *
1222  *      Fun:   cmPkTknStr4
1223  *
1224  *      Desc:  This function packs a token string of size 4
1225  *
1226  *      Ret:   ROK      - ok
1227  *
1228  *      Notes: None
1229  *
1230         File:  cm_gen.c
1231  *
1232  */
1233   
1234 #ifdef ANSI
1235 PUBLIC S16 cmPkTknStr4
1236 (
1237 TknStr4 *tknStr,             /* token string */
1238 Buffer  *mBuf                /* message buffer */
1239 )
1240 #else
1241 PUBLIC S16 cmPkTknStr4(tknStr, mBuf)
1242 TknStr4 *tknStr;             /* token string */
1243 Buffer  *mBuf;               /* message buffer */
1244 #endif
1245 {
1246    TRC2(cmPkTknStr4)
1247
1248    CMPKTKNSTR(tknStr, mBuf);
1249
1250    RETVALUE(ROK);
1251
1252 } /* end of cmPkTknStr4 */
1253
1254
1255 \f
1256 /*
1257  *
1258  *      Fun:   cmPkTknStr12
1259  *
1260  *      Desc:  This function packs a token string of size 4
1261  *
1262  *      Ret:   ROK      - ok
1263  *
1264  *      Notes: None
1265  *
1266         File:  cm_gen.c
1267  *
1268  */
1269   
1270 #ifdef ANSI
1271 PUBLIC S16 cmPkTknStr12
1272 (
1273 TknStr12 *tknStr,             /* token string */
1274 Buffer   *mBuf                /* message buffer */
1275 )
1276 #else
1277 PUBLIC S16 cmPkTknStr12(tknStr, mBuf)
1278 TknStr12 *tknStr;             /* token string */
1279 Buffer   *mBuf;               /* message buffer */
1280 #endif
1281 {
1282    TRC2(cmPkTknStr12)
1283
1284    CMPKTKNSTR(tknStr, mBuf);
1285
1286    RETVALUE(ROK);
1287
1288 } /* end of cmPkTknStr12 */
1289
1290 \f
1291 /*
1292  *
1293  *      Fun:   cmPkTknStr32
1294  *
1295  *      Desc:  This function packs a token string of size 4
1296  *
1297  *      Ret:   ROK      - ok
1298  *
1299  *      Notes: None
1300  *
1301         File:  cm_gen.c
1302  *
1303  */
1304   
1305 #ifdef ANSI
1306 PUBLIC S16 cmPkTknStr32
1307 (
1308 TknStr32 *tknStr,             /* token string */
1309 Buffer   *mBuf                /* message buffer */
1310 )
1311 #else
1312 PUBLIC S16 cmPkTknStr32(tknStr, mBuf)
1313 TknStr32 *tknStr;             /* token string */
1314 Buffer   *mBuf;               /* message buffer */
1315 #endif
1316 {
1317    TRC2(cmPkTknStr32)
1318
1319    CMPKTKNSTR(tknStr, mBuf);
1320
1321    RETVALUE(ROK);
1322
1323 } /* end of cmPkTknStr32 */
1324
1325 \f
1326 /*
1327  *
1328  *      Fun:   cmPkTknStr64
1329  *
1330  *      Desc:  This function packs a token string of size 4
1331  *
1332  *      Ret:   ROK      - ok
1333  *
1334  *      Notes: None
1335  *
1336         File:  cm_gen.c
1337  *
1338  */
1339   
1340 #ifdef ANSI
1341 PUBLIC S16 cmPkTknStr64
1342 (
1343 TknStr64 *tknStr,             /* token string */
1344 Buffer   *mBuf                /* message buffer */
1345 )
1346 #else
1347 PUBLIC S16 cmPkTknStr64(tknStr, mBuf)
1348 TknStr64 *tknStr;             /* token string */
1349 Buffer   *mBuf;               /* message buffer */
1350 #endif
1351 {
1352    TRC2(cmPkTknStr64)
1353
1354    CMPKTKNSTR(tknStr, mBuf);
1355
1356    RETVALUE(ROK);
1357
1358 } /* end of cmPkTknStr64 */
1359
1360 \f
1361 /*
1362  *
1363  *      Fun:   cmPkTknStr132
1364  *
1365  *      Desc:  This function packs a token string of size 4
1366  *
1367  *      Ret:   ROK      - ok
1368  *
1369  *      Notes: None
1370  *
1371         File:  cm_gen.c
1372  *
1373  */
1374   
1375 #ifdef ANSI
1376 PUBLIC S16 cmPkTknStr132
1377 (
1378 TknStr132 *tknStr,             /* token string */
1379 Buffer   *mBuf                /* message buffer */
1380 )
1381 #else
1382 PUBLIC S16 cmPkTknStr132(tknStr, mBuf)
1383 TknStr132 *tknStr;             /* token string */
1384 Buffer   *mBuf;               /* message buffer */
1385 #endif
1386 {
1387    TRC2(cmPkTknStr132)
1388
1389    CMPKTKNSTR(tknStr, mBuf);
1390
1391    RETVALUE(ROK);
1392
1393 } /* end of cmPkTknStr132 */
1394
1395 \f
1396 /*
1397  *
1398  *      Fun:   cmPkTknStr256
1399  *
1400  *      Desc:  This function packs a token string of size 4
1401  *
1402  *      Ret:   ROK      - ok
1403  *
1404  *      Notes: None
1405  *
1406         File:  cm_gen.c
1407  *
1408  */
1409   
1410 #ifdef ANSI
1411 PUBLIC S16 cmPkTknStr256
1412 (
1413 TknStr256 *tknStr,             /* token string */
1414 Buffer    *mBuf                /* message buffer */
1415 )
1416 #else
1417 PUBLIC S16 cmPkTknStr256(tknStr, mBuf)
1418 TknStr256 *tknStr;             /* token string */
1419 Buffer    *mBuf;               /* message buffer */
1420 #endif
1421 {
1422    TRC2(cmPkTknStr256)
1423
1424    CMPKTKNSTR(tknStr, mBuf);
1425
1426    RETVALUE(ROK);
1427
1428 } /* end of cmPkTknStr256 */
1429
1430 \f
1431 /*
1432  *
1433  *      Fun:   cmPkTknOid
1434  *
1435  *      Desc:  This function packs a Object Identifier token
1436  *
1437  *      Ret:   ROK      - ok
1438  *
1439  *      Notes: None
1440  *
1441         File:  cm_gen.c
1442  *
1443  */
1444   
1445 #ifdef ANSI
1446 PUBLIC S16 cmPkTknOid
1447 (
1448 TknOid   *tknOid,             /* Object Identifier token */
1449 Buffer   *mBuf                /* message buffer */
1450 )
1451 #else
1452 PUBLIC S16 cmPkTknOid(tknOid, mBuf)
1453 TknOid   *tknOid;             /* Object Identifier token */
1454 Buffer   *mBuf;               /* message buffer */
1455 #endif
1456 {
1457    U16    i;
1458
1459    TRC2(cmPkTknOid)
1460  
1461    if (tknOid->pres == TRUE)
1462    {
1463       /* Pack the value */
1464       for (i = 0; i < (U16)tknOid->len; i++)
1465       {
1466          /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
1467           * with compilation flag TKNOID_U16 */
1468 #ifndef TKNOID_U16
1469          CMCHKPK(SPkU32, tknOid->val[i], mBuf);
1470 #else
1471          CMCHKPK(SPkU16, tknOid->val[i], mBuf);
1472 #endif  /* !TKNOID_U16 */
1473       }
1474       /* Pack the length */
1475       CMCHKPK(SPkU8, tknOid->len, mBuf);
1476    }
1477    /* Pack the token header */
1478    CMCHKPK(SPkU8, tknOid->pres, mBuf);
1479
1480    RETVALUE(ROK);
1481 } /* end of cmPkTknOid */
1482
1483 \f
1484 /*
1485 *
1486 *      Fun:   cmPkTknS32
1487 *
1488 *      Desc:  This function packs a token S32
1489 *
1490 *      Ret:   ROK      - ok
1491 *
1492 *      Notes: None
1493 *
1494 *      File:  cm_gen.c
1495 *
1496 */
1497   
1498 #ifdef ANSI
1499 PUBLIC S16 cmPkTknS32
1500 (
1501 TknS32 *tknS32,             /* token S32 */
1502 Buffer *mBuf                /* message buffer */
1503 )
1504 #else
1505 PUBLIC S16 cmPkTknS32(tknS32, mBuf)
1506 TknS32 *tknS32;             /* token S32 */
1507 Buffer *mBuf;               /* message buffer */
1508 #endif
1509 {
1510    TRC2(cmPkTknS32)
1511
1512    if (tknS32->pres)
1513    {
1514       /* Value */
1515       CMCHKPK(SPkS32, tknS32->val, mBuf);
1516    }
1517
1518    /* Token Header */
1519    CMCHKPK(SPkU8, tknS32->pres, mBuf);
1520
1521    RETVALUE(ROK);
1522 } /* end of cmPkTknS32 */
1523
1524 \f
1525 /*
1526 *
1527 *       Fun:   cmPkHeader
1528 *
1529 *       Desc:  This function packs the header structure
1530 *
1531 *       Ret:   ROK      - ok
1532 *
1533 *       Notes: None.
1534 *
1535 *       File:  cm_gen.c
1536 *
1537 */
1538   
1539 #ifdef ANSI
1540 PUBLIC S16 cmPkHeader
1541 (
1542 Header *header,             /* header */
1543 Buffer *mBuf                /* message buffer */
1544 )
1545 #else
1546 PUBLIC S16 cmPkHeader(header, mBuf)
1547 Header *header;             /* header */
1548 Buffer *mBuf;               /* message buffer */
1549 #endif
1550 {
1551    TRC2(cmPkHeader)
1552
1553 #ifdef LMINT3
1554    CMCHKPK(cmPkMemoryId, &header->response.mem, mBuf);
1555    CMCHKPK(cmPkRoute, header->response.route, mBuf);
1556    CMCHKPK(cmPkPriority, header->response.prior, mBuf);
1557    CMCHKPK(cmPkSelector, header->response.selector, mBuf);
1558    CMCHKPK(cmPkTranId, header->transId, mBuf);
1559 #endif /* LMINT3 */
1560    CMCHKPK(cmPkElmntId, &header->elmId, mBuf);
1561    CMCHKPK(cmPkEntityId, &header->entId, mBuf);
1562    CMCHKPK(SPkU16, header->seqNmb, mBuf);
1563    CMCHKPK(SPkU8, header->version, mBuf);
1564    CMCHKPK(SPkU8, header->msgType, mBuf);
1565    CMCHKPK(SPkU16, header->msgLen, mBuf);
1566
1567    RETVALUE(ROK);
1568 } /* end of cmPkHeader */
1569
1570 \f
1571 /*
1572 *
1573 *       Fun:   cmPkCmStatus
1574 *
1575 *       Desc:  This function packs common management status structure
1576 *
1577 *       Ret:   ROK      - ok
1578 *
1579 *       Notes: None.
1580 *
1581 *       File:  cm_gen.c
1582 *
1583 */
1584   
1585 #ifdef ANSI
1586 PUBLIC S16 cmPkCmStatus
1587 (
1588 CmStatus *sta,              /* status structure */
1589 Buffer *mBuf                /* message buffer */
1590 )
1591 #else
1592 PUBLIC S16 cmPkCmStatus(sta, mBuf)
1593 CmStatus *sta;              /* status structure */
1594 Buffer *mBuf;               /* message buffer */
1595 #endif
1596 {
1597    TRC2(cmPkCmStatus)
1598
1599    CMCHKPK(SPkU16, sta->reason, mBuf);
1600    CMCHKPK(SPkU16, sta->status, mBuf);
1601
1602    RETVALUE(ROK);
1603 } /* end of cmPkCmStatus */
1604
1605 \f
1606 /*
1607 *
1608 *       Fun:   cmPkCmAlarm
1609 *
1610 *       Desc:  This function packs common management alarm structure
1611 *
1612 *       Ret:   ROK      - ok
1613 *
1614 *       Notes: None.
1615 *
1616 *       File:  cm_gen.c
1617 *
1618 */
1619   
1620 #ifdef ANSI
1621 PUBLIC S16 cmPkCmAlarm
1622 (
1623 CmAlarm *alarm,            /* alarm structure */
1624 Buffer  *mBuf              /* message buffer */
1625 )
1626 #else
1627 PUBLIC S16 cmPkCmAlarm(alarm, mBuf)
1628 CmAlarm *alarm;             /* alarm structure */
1629 Buffer *mBuf;               /* message buffer */
1630 #endif
1631 {
1632    TRC2(cmPkCmAlarm)
1633
1634    CMCHKPK(SPkU16, alarm->cause, mBuf);
1635    CMCHKPK(SPkU16, alarm->event, mBuf);
1636    CMCHKPK(SPkU16, alarm->category, mBuf);
1637    CMCHKPK(cmPkDateTime, &alarm->dt, mBuf);
1638
1639    RETVALUE(ROK);
1640 } /* end of cmPkCmAlarm */
1641
1642 \f
1643 /*
1644 *
1645 *       Fun:   cmPkSmCfg
1646 *
1647 *       Desc:  This function packs the stack manager structure
1648 *
1649 *       Ret:   ROK      - ok
1650 *
1651 *       Notes: None.
1652 *
1653 *       File:  cm_gen.c
1654 *
1655 */
1656   
1657 #ifdef ANSI
1658 PUBLIC S16 cmPkSmCfg
1659 (
1660 SmCfg *smCfg,           /* stack manager */
1661 Buffer *mBuf            /* message buffer */
1662 )
1663 #else
1664 PUBLIC S16 cmPkSmCfg(smCfg, mBuf)
1665 SmCfg *smCfg;           /* stack manager */
1666 Buffer *mBuf;           /* message buffer */
1667 #endif
1668 {
1669    TRC2(cmPkSmCfg)
1670
1671    CMCHKPK(cmPkSelector, smCfg->selector, mBuf); 
1672    CMCHKPK(cmPkRoute, smCfg->route, mBuf); 
1673    CMCHKPK(cmPkPrior, smCfg->prior, mBuf); 
1674    CMCHKPK(cmPkPool, smCfg->pool, mBuf); 
1675    CMCHKPK(cmPkRegion, smCfg->region, mBuf);
1676    CMCHKPK(cmPkInst, smCfg->inst, mBuf);
1677    CMCHKPK(cmPkEnt, smCfg->ent, mBuf);
1678
1679    RETVALUE(ROK);
1680 } /* end of cmPkSmCfg */
1681
1682 \f
1683 /*
1684 *
1685 *       Fun:   cmPkTmrCfg
1686 *
1687 *       Desc:  This function packs the timer configuration structure
1688 *
1689 *       Ret:   ROK      - ok
1690 *
1691 *       Notes: None.
1692 *
1693 *       File:  cm_gen.c
1694 *
1695 */
1696   
1697 #ifdef ANSI
1698 PUBLIC S16 cmPkTmrCfg
1699 (
1700 TmrCfg *tmrCfg,         /* timer configuration */
1701 Buffer *mBuf            /* message buffer */
1702 )
1703 #else
1704 PUBLIC S16 cmPkTmrCfg(tmrCfg, mBuf)
1705 TmrCfg *tmrCfg;         /* timer configuration */
1706 Buffer *mBuf;           /* message buffer */
1707 #endif
1708 {
1709    TRC2(cmPkTmrCfg)
1710
1711    CMCHKPK(SPkU16, tmrCfg->val, mBuf);
1712    CMCHKPK(cmPkBool, tmrCfg->enb, mBuf);
1713
1714    RETVALUE(ROK);
1715 } /* end of cmPkTmrCfg */
1716
1717 \f
1718 /*
1719  *
1720  *      Fun:   cmPkTknBuf
1721  *
1722  *      Desc:  This function packs a token buffer
1723  *
1724  *      Ret:   ROK      - ok
1725  *
1726  *      Notes: None
1727  *
1728         File:  cm_gen.c
1729  *
1730  */
1731   
1732 #ifdef ANSI
1733 PUBLIC S16 cmPkTknBuf
1734 (
1735 TknBuf *tknBuf,                /* token string */
1736 Buffer    *mBuf                /* message buffer */
1737 )
1738 #else
1739 PUBLIC S16 cmPkTknBuf(tknBuf, mBuf)
1740 TknBuf *tknBuf;                /* token string */
1741 Buffer    *mBuf;               /* message buffer */
1742 #endif
1743 {
1744    TRC2(cmPkTknBuf)
1745
1746    if(tknBuf->pres)
1747    {
1748       MsgLen msgLen;
1749
1750       SFndLenMsg(tknBuf->val, &msgLen);
1751       if( SCatMsg(mBuf, tknBuf->val, M2M1) != ROK )
1752       {
1753          RETVALUE(RFAILED);
1754       }
1755       cmPkMsgLen(msgLen, mBuf);
1756       SPutMsg(tknBuf->val);
1757    }
1758   
1759    /* Token Header */
1760    CMCHKPK(SPkU8, tknBuf->pres, mBuf);
1761
1762    RETVALUE(ROK);
1763 } /* end of cmPkTknBuf */
1764
1765 #ifdef TDS_ROLL_UPGRADE_SUPPORT
1766 /*
1767 *
1768 *       Fun:   cmPkIntf
1769 *
1770 *       Desc:  This function packs the interface information
1771 *
1772 *       Ret:   ROK      - ok
1773 *
1774 *       Notes: None.
1775 *
1776 *       File:  cm_gen.c
1777 *
1778 */
1779   
1780 #ifdef ANSI
1781 PUBLIC S16 cmPkIntf
1782 (
1783 CmIntf *intf,           /* interface info */
1784 Buffer *mBuf            /* message buffer */
1785 )
1786 #else
1787 PUBLIC S16 cmPkIntf(intf, mBuf)
1788 CmIntf *intf;           /* interface info */
1789 Buffer *mBuf;           /* message buffer */
1790 #endif
1791 {
1792    TRC2(cmPkIntf)
1793
1794    CMCHKPK(cmPkIntfId,  intf->intfId,  mBuf); 
1795    CMCHKPK(cmPkIntfVer, intf->intfVer, mBuf); 
1796
1797    RETVALUE(ROK);
1798 } /* end of cmPkIntf */
1799 #endif /* TDS_ROLL_UPGRADE_SUPPORT */
1800
1801 \f
1802 /*
1803  *   common unpacking functions 
1804  */
1805
1806 \f
1807 /*
1808 *
1809 *       Fun:   cmUnpkDateTime
1810 *
1811 *       Desc:  This function is used to Unpack Pack Date Time structure
1812 *
1813 *       Ret:   ROK      - ok
1814 *
1815 *       Notes: None
1816 *
1817 *       File:  cm_gen.c
1818 *
1819 */
1820   
1821 #ifdef ANSI
1822 PUBLIC S16 cmUnpkDateTime
1823 (
1824 DateTime *dateTime,  /* date/time structure */
1825 Buffer *mBuf         /* message buffer */
1826 )
1827 #else
1828 PUBLIC S16 cmUnpkDateTime(dateTime, mBuf)
1829 DateTime *dateTime;  /* date/time structure */
1830 Buffer *mBuf;        /* message buffer */
1831 #endif
1832 {
1833    TRC2(cmUnpDateTime)
1834
1835    CMCHKUNPK(SUnpkU8, &dateTime->month, mBuf); 
1836    CMCHKUNPK(SUnpkU8, &dateTime->day, mBuf); 
1837    CMCHKUNPK(SUnpkU8, &dateTime->year, mBuf); 
1838    CMCHKUNPK(SUnpkU8, &dateTime->hour, mBuf); 
1839    CMCHKUNPK(SUnpkU8, &dateTime->min, mBuf); 
1840    CMCHKUNPK(SUnpkU8, &dateTime->sec, mBuf); 
1841    CMCHKUNPK(SUnpkU8, &dateTime->tenths, mBuf);
1842
1843    /*-- added for micro seconds --*/
1844 #ifdef SS_DATETIME_USEC
1845    CMCHKUNPK(SUnpkU32, &dateTime->usec, mBuf);
1846 #endif /*-- SS_DATETIME_USEC --*/
1847
1848    RETVALUE(ROK);
1849 } /* end of cmUnpkDateTime */
1850
1851 \f
1852 /*
1853 *
1854 *       Fun:   cmUnpkDuration
1855 *
1856 *       Desc:  This function is used to Unpack Pack Duration structure
1857 *
1858 *       Ret:   ROK      - ok
1859 *
1860 *       Notes: None
1861 *
1862 *       File:  cm_gen.c
1863 *
1864 */
1865   
1866 #ifdef ANSI
1867 PUBLIC S16 cmUnpkDuration
1868 (
1869 Duration *duration,  /* duration structure */
1870 Buffer *mBuf         /* message buffer */
1871 )
1872 #else
1873 PUBLIC S16 cmUnpkDuration(duration, mBuf)
1874 Duration *duration;  /* duration structure */
1875 Buffer *mBuf;        /* message buffer */
1876 #endif
1877 {
1878    TRC2(cmUnpDuration)
1879
1880    CMCHKUNPK(SUnpkU8, &duration->days, mBuf); 
1881    CMCHKUNPK(SUnpkU8, &duration->hours, mBuf); 
1882    CMCHKUNPK(SUnpkU8, &duration->mins, mBuf); 
1883    CMCHKUNPK(SUnpkU8, &duration->secs, mBuf); 
1884    CMCHKUNPK(SUnpkU8, &duration->tenths, mBuf);
1885
1886    RETVALUE(ROK);
1887 } /* end of cmUnpkDuration */
1888
1889 /*
1890 *
1891 *       Fun:   cmUnpkPtr
1892 *
1893 *       Desc:  This function is used to Unpack Ptr type
1894 *
1895 *       Ret:   ROK      - ok
1896 *
1897 *       Notes: None
1898 *
1899 *       File:  cm_gen.c
1900 *
1901 */
1902   
1903 #ifdef ANSI
1904 PUBLIC S16 cmUnpkPtr
1905 (
1906 PTR *ptr,  /* duration structure */
1907 Buffer *mBuf    /* message buffer */
1908 )
1909 #else
1910 PUBLIC S16 cmUnpkPtr(ptr, mBuf)
1911 PTR *ptr;  /* duration structure */
1912 Buffer *mBuf;   /* message buffer */
1913 #endif
1914 {
1915    U16 tmp16;               /* temporary value */
1916    U32 tmp32;               /* temporary value */
1917    Data unpkArray[PTRSIZE]; /* unpacking array */
1918    S16 ret;                 /* return code */
1919
1920 #if (defined(ALPHA) || defined(BIT_64))
1921    U64 tmp64;
1922 #endif
1923    
1924    TRC2(cmUnpkPtr)
1925
1926    switch (PTRSIZE)
1927    {
1928       case 2:
1929          ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
1930          if (ret != ROK)
1931             RETVALUE(ret);
1932
1933          tmp16 = 0; 
1934 #ifndef FCSPKINT            /* backward compatibility, packing order */
1935          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
1936          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
1937 #else                       /* forward compatibility, packing order */
1938          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
1939          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
1940 #endif
1941          *ptr = tmp16;
1942          break;
1943
1944       case 4:
1945          ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
1946          if (ret != ROK)
1947             RETVALUE(ret);
1948
1949          tmp16 = 0;
1950          tmp32 = 0; 
1951 #ifndef FCSPKINT            /* backward compatibility, packing order */
1952          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
1953          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
1954          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
1955          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
1956          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
1957          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
1958 #else                       /* forward compatibility, packing order */
1959          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
1960          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
1961          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
1962          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
1963          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
1964          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
1965 #endif
1966          *ptr = tmp32;
1967          break;
1968
1969       case 8:
1970 #if(defined(ALPHA) || defined(BIT_64))
1971          ret = SRemPreMsgMult(unpkArray, (MsgLen) 8, mBuf);
1972          if (ret != ROK)
1973             RETVALUE(ret);
1974
1975          tmp16 = 0;
1976          tmp32 = 0; 
1977          tmp64 = 0;
1978 #ifndef FCSPKINT            /* backward compatibility, packing order */
1979          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[7]);
1980          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[6]);
1981          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
1982          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[5]);
1983          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[4]);
1984          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
1985          tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
1986          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
1987          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
1988          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
1989          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
1990          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
1991          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
1992          tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
1993 #else                       /* forward compatibility, packing order */
1994          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
1995          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
1996          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
1997          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
1998          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
1999          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
2000          tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
2001          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[4]);
2002          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[5]);
2003          tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
2004          tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[6]);
2005          tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[7]);
2006          tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
2007          tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
2008 #endif
2009          *ptr = tmp64;
2010          break;
2011 #endif
2012       default:
2013          /* no support for U64 */
2014          ret = RFAILED;
2015    }
2016
2017    RETVALUE(ret);
2018 } /* end of cmUnpkPtr */
2019
2020 \f
2021 /*
2022 *
2023 *       Fun:   cmUnpkEntityId
2024 *
2025 *       Desc:  This function unpacks the EntityId structure
2026 *
2027 *       Ret:   ROK      - ok
2028 *
2029 *       Notes: None.
2030 *
2031 *       File:  cm_gen.c
2032 *
2033 */
2034   
2035 #ifdef ANSI
2036 PUBLIC S16 cmUnpkEntityId
2037 (
2038 EntityId *entityId,        /* entity id */
2039 Buffer   *mBuf             /* message buffer */
2040 )
2041 #else
2042 PUBLIC S16 cmUnpkEntityId(entityId, mBuf)
2043 EntityId *entityId;        /* entity id */
2044 Buffer   *mBuf;            /* message buffer */
2045 #endif
2046 {
2047    TRC2(cmUnpkEntityId)
2048
2049    CMCHKUNPK(cmUnpkEnt, &entityId->ent, mBuf); 
2050    CMCHKUNPK(cmUnpkInst, &entityId->inst, mBuf);
2051
2052    RETVALUE(ROK);
2053 } /* end of cmUnpkEntityId */
2054
2055 \f
2056 /*
2057 *
2058 *       Fun:   cmUnpkElmntId
2059 *
2060 *       Desc:  This function unpacks the ElmntId structure
2061 *
2062 *       Ret:   ROK      - ok
2063 *
2064 *       Notes: None.
2065 *
2066 *       File:  cm_gen.c
2067 *
2068 */
2069   
2070 #ifdef ANSI
2071 PUBLIC S16 cmUnpkElmntId
2072 (
2073 ElmntId *elmntId,         /* element id */
2074 Buffer  *mBuf             /* message buffer */
2075 )
2076 #else
2077 PUBLIC S16 cmUnpkElmntId(elmntId, mBuf)
2078 ElmntId *elmntId;         /* element id */
2079 Buffer  *mBuf;            /* message buffer */
2080 #endif
2081 {
2082    TRC2(cmUnpkElmntId)
2083
2084    CMCHKUNPK(cmUnpkElmnt, &elmntId->elmnt, mBuf); 
2085    CMCHKUNPK(cmUnpkElmntInst1, &elmntId->elmntInst1, mBuf); 
2086    CMCHKUNPK(cmUnpkElmntInst2, &elmntId->elmntInst2, mBuf); 
2087    CMCHKUNPK(cmUnpkElmntInst3, &elmntId->elmntInst3, mBuf);
2088
2089    RETVALUE(ROK);
2090 } /* end of cmUnpkElmntId */
2091
2092 \f
2093 /*
2094 *
2095 *       Fun:   cmUnpkMemoryId
2096 *
2097 *       Desc:  This function unpacks the MemoryId structure
2098 *
2099 *       Ret:   ROK      - ok
2100 *
2101 *       Notes: None.
2102 *
2103 *       File:  cm_gen.c
2104 *
2105 */
2106   
2107 #ifdef ANSI
2108 PUBLIC S16 cmUnpkMemoryId
2109 (
2110 MemoryId *memoryId,        /* memoryId */
2111 Buffer   *mBuf             /* message buffer */
2112 )
2113 #else
2114 PUBLIC S16 cmUnpkMemoryId(memoryId, mBuf)
2115 MemoryId *memoryId;        /* memoryId */
2116 Buffer   *mBuf;            /* message buffer */
2117 #endif
2118 {
2119    TRC2(cmUnpkMemoryId)
2120
2121    CMCHKUNPK(cmUnpkRegion, &memoryId->region,   mBuf); 
2122    CMCHKUNPK(cmUnpkPool, &memoryId->pool, mBuf);
2123
2124    RETVALUE(ROK);
2125 } /* end of cmUnpkMemoryId */
2126
2127 \f
2128 /*
2129 *
2130 *       Fun:   cmUnpkSystemId
2131 *
2132 *       Desc:  This function packs the System Id structure
2133 *
2134 *       Ret:   ROK      - ok
2135 *
2136 *       Notes: None.
2137 *
2138 *       File:  cm_gen.c
2139 *
2140 */
2141   
2142 #ifdef ANSI
2143 PUBLIC S16 cmUnpkSystemId
2144 (
2145 SystemId *systemId,         /* system id */
2146 Buffer   *mBuf              /* message buffer */
2147 )
2148 #else
2149 PUBLIC S16 cmUnpkSystemId(systemId, mBuf)
2150 SystemId *systemId;         /* system id */
2151 Buffer   *mBuf;             /* message buffer */
2152 #endif
2153 {
2154    S16 i;               /* loop counter */
2155    MsgLen len;
2156    
2157    TRC2(cmUnpkSystemId)
2158
2159    CMCHKUNPK(SUnpkS16, &systemId->mVer, mBuf); 
2160    CMCHKUNPK(SUnpkS16, &systemId->mRev, mBuf); 
2161    CMCHKUNPK(SUnpkS16, &systemId->bVer, mBuf); 
2162    CMCHKUNPK(SUnpkS16, &systemId->bRev, mBuf);
2163
2164    SFndLenMsg(mBuf, &len);
2165    
2166    for (i = 0; i < len; i++)
2167    {
2168      CMCHKUNPK(cmUnpkTxt, &systemId->ptNmb[i], mBuf);
2169    }
2170    
2171    RETVALUE(ROK);
2172 } /* end of cmUnpkSystemId */
2173
2174
2175
2176 /*
2177  *
2178  *       Fun:   cmUnpkProtAddr   
2179  *
2180  *       Desc:  This function will unpack protocol address.
2181  *
2182  *       Ret:   ROK on success
2183  *              RFAILED on error
2184  *
2185  *       Notes: None
2186  *
2187          File:  cm_gen.c
2188  *
2189  */
2190
2191 #ifdef ANSI
2192 PUBLIC S16 cmUnpkProtAddr
2193 (
2194 ProtAddr     *pAddr,         /* protocol address */
2195 Buffer       *mBuf           /* buffer */
2196 )
2197 #else
2198 PUBLIC S16 cmUnpkProtAddr(pAddr, mBuf)
2199 ProtAddr     *pAddr;         /* protocol address table */
2200 Buffer       *mBuf;          /* buffer */
2201 #endif
2202 {
2203    U8               j;                  /* Index */
2204
2205    TRC3(cmUnpkProtAddr)
2206
2207    CMCHKUNPK(SUnpkU16,  &(pAddr->protType), mBuf);  
2208    CMCHKUNPK(SUnpkU8,   &(pAddr->len), mBuf);  
2209    CMCHKUNPK(SUnpkU8,   &(pAddr->preLen), mBuf);  
2210
2211    for (j =0; j <  pAddr->len; j++)
2212       CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);  
2213    
2214 #ifdef CM_ARI2
2215    CMCHKUNPK(cmUnpkBool,   &(pAddr->autoSysIdPres), mBuf);  
2216    CMCHKUNPK(SUnpkU32,  &(pAddr->autoSysId), mBuf);  
2217 #endif /* CM_ARI2 */
2218    RETVALUE(ROK);
2219
2220 } /* end of cmUnpkProtAddr */
2221    
2222
2223 /*
2224  *
2225  *       Fun:   cmUnpkProtAddrTbl
2226  *
2227  *       Desc:  This function will pack protocol addresses.
2228  *
2229  *       Ret:   ROK on success
2230  *              RFAILED on error
2231  *
2232  *       Notes: None
2233  *
2234          File:  cm_gen.c
2235  *
2236  */
2237
2238 #ifdef ANSI
2239 PUBLIC S16 cmUnpkProtAddrTbl
2240 (
2241 ProtAddrTbl  *protAddr,      /* protocol address table */
2242 Buffer       *mBuf           /* buffer */
2243 )
2244 #else
2245 PUBLIC S16 cmUnpkProtAddrTbl(protAddr, mBuf)
2246 ProtAddrTbl  *protAddr;      /* protocol address table */
2247 Buffer       *mBuf;          /* buffer */
2248 #endif
2249 {
2250    U8               i;                  /* index */
2251    U8               j;                  /* Index */
2252    ProtAddr         *pAddr;             /* Protocol Address */
2253
2254    TRC3(cmUnpkProtAddrTbl)
2255
2256    CMCHKUNPK(SUnpkU8, &protAddr->count, mBuf);  
2257    for (i = 0;  i < protAddr->count; i++)
2258    {
2259        pAddr = &(protAddr->addr[i]);
2260
2261        CMCHKUNPK(SUnpkU16,  &(pAddr->protType), mBuf);  
2262        CMCHKUNPK(SUnpkU8,  &(pAddr->len), mBuf);  
2263        CMCHKUNPK(SUnpkU8, &(pAddr->preLen), mBuf);  
2264
2265         
2266        for (j =0; j <  pAddr->len; j++)
2267           CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);  
2268
2269 #ifdef CM_ARI2
2270        CMCHKUNPK(cmUnpkBool,   &(pAddr->autoSysIdPres), mBuf);
2271        CMCHKUNPK(SUnpkU32,  &(pAddr->autoSysId), mBuf);
2272 #endif /* CM_ARI2 */
2273    }
2274    RETVALUE(ROK);
2275 } /* end of cmUnpkProtAddrTbl */
2276    
2277
2278 /*
2279 *
2280 *       Fun:   cmUnpkAddrs
2281 *
2282 *       Desc:  This function is used to unpack the Addrs structure
2283 *
2284 *       Ret:   ROK - ok
2285 *
2286 *       Notes: None
2287 *
2288 *       File:  cm_gen.c
2289 *
2290 */
2291   
2292 #ifdef ANSI
2293 PUBLIC S16 cmUnpkAddrs
2294 (
2295 Addrs *addrs,     /* address */
2296 Buffer *mBuf      /* message buffer */
2297 )
2298 #else
2299 PUBLIC S16 cmUnpkAddrs(addrs, mBuf)
2300 Addrs *addrs;     /* address */
2301 Buffer *mBuf;     /* message buffer */
2302 #endif
2303 {
2304    U8 i;          /* loop counter */
2305
2306    TRC2(cmUnpAddrs)
2307
2308    CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
2309
2310    if (addrs->length > ADRLEN)
2311       RETVALUE(RFAILED);
2312    
2313    for(i = 0; i < addrs->length; i++)
2314    {
2315       CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
2316    }
2317
2318    RETVALUE(ROK);
2319 } /* end of cmUnpkAddrs */
2320
2321 /*
2322 *
2323 *       Fun:   cmUnpkShrtAddrs
2324 *
2325 *       Desc:  This function is used to unpack the ShrtAddrs structure
2326 *
2327 *       Ret:   ROK - ok
2328 *
2329 *       Notes: None
2330 *
2331 *       File:  cm_gen.c
2332 *
2333 */
2334   
2335 #ifdef ANSI
2336 PUBLIC S16 cmUnpkShrtAddrs
2337 (
2338 ShrtAddrs *addrs,    /* address */
2339 Buffer    *mBuf      /* message buffer */
2340 )
2341 #else
2342 PUBLIC S16 cmUnpkShrtAddrs(addrs, mBuf)
2343 ShrtAddrs *addrs;    /* address */
2344 Buffer    *mBuf;     /* message buffer */
2345 #endif
2346 {
2347    U8 i;          /* loop counter */
2348
2349    TRC2(cmUnpShrtAddrs)
2350
2351    CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
2352
2353    if (addrs->length > SHRTADRLEN)
2354       RETVALUE(RFAILED);
2355    
2356    for(i = 0; i < addrs->length; i++)
2357    {
2358       CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
2359    }
2360    RETVALUE(ROK);
2361 } /* end of cmUnpkShrtAddrs */
2362
2363 \f
2364 /*
2365 *
2366 *       Fun:   cmUnpkAddrMask
2367 *
2368 *       Desc:  This unpacks address mask.
2369 *
2370 *       Ret:   ROK      - ok
2371 *
2372 *       Notes: None
2373 *
2374 *       File:  cm_gen.c
2375 *
2376 */
2377   
2378 #ifdef ANSI
2379 PUBLIC S16 cmUnpkAddrMask
2380 (
2381 U8 *mask,             /* pointer to address mask */
2382 Buffer  *mBuf         /* message buffer */
2383 )
2384 #else
2385 PUBLIC S16 cmUnpkAddrMask(mask, mBuf)
2386 U8 *mask;             /* pointer to address mask */
2387 Buffer  *mBuf;        /* message buffer */
2388 #endif
2389 {
2390    S16 i;             /* counter */
2391
2392    TRC2(cmUnpAddrMask)
2393
2394    /* unpack address mask */
2395    for (i = 0; i< ADRLEN; i++) 
2396    {
2397       CMCHKUNPK(SUnpkU8, &mask[i], mBuf);
2398    }
2399    RETVALUE(ROK);
2400 } /* end of cmUnpkAddrMask */
2401
2402 \f
2403 /*
2404 *
2405 *       Fun:   cmUnpkBndCfg
2406 *
2407 *       Desc:  This function unpacks the BndCfg structure
2408 *
2409 *       Ret:   ROK      - ok
2410 *
2411 *       Notes: None.
2412 *
2413 *       File:  cm_gen.c
2414 *
2415 */
2416   
2417 #ifdef ANSI
2418 PUBLIC S16 cmUnpkBndCfg
2419 (
2420 BndCfg *bndCfg,         /* bndCfg */
2421 Buffer *mBuf            /* message buffer */
2422 )
2423 #else
2424 PUBLIC S16 cmUnpkBndCfg(bndCfg, mBuf)
2425 BndCfg *bndCfg;         /* bndCfg */
2426 Buffer *mBuf;           /* message buffer */
2427 #endif
2428 {
2429    S16 i;               /* loop counter */
2430
2431    TRC2(cmUnpBndCfg)
2432
2433    for (i = 0; bndCfg->usrId[i]; i++);
2434    CMCHKUNPK(cmUnpkTxt, bndCfg->usrId+i, mBuf);
2435
2436    CMCHKUNPK(SUnpkU8, &bndCfg->bufOwnshp, mBuf); 
2437    CMCHKUNPK(SUnpkU8, &bndCfg->flcTyp, mBuf); 
2438    CMCHKUNPK(SUnpkU8, &bndCfg->wdw, mBuf); 
2439    CMCHKUNPK(cmUnpkEnt, &bndCfg->ent, mBuf); 
2440    CMCHKUNPK(cmUnpkInst, &bndCfg->inst, mBuf); 
2441    CMCHKUNPK(cmUnpkRegion, &bndCfg->region, mBuf); 
2442    CMCHKUNPK(cmUnpkPool, &bndCfg->pool, mBuf); 
2443    CMCHKUNPK(cmUnpkPrior, &bndCfg->prior, mBuf); 
2444    CMCHKUNPK(cmUnpkRoute, &bndCfg->route, mBuf); 
2445    CMCHKUNPK(cmUnpkAddrs, &bndCfg->sapAdr, mBuf); 
2446    CMCHKUNPK(cmUnpkSelector, &bndCfg->selector, mBuf);
2447
2448    RETVALUE(ROK);
2449 } /* end of cmUnpkBndCfg */
2450
2451 \f
2452 /*
2453 *
2454 *       Fun:   cmUnpkPst
2455 *
2456 *       Desc:  pack post structure 
2457 *
2458 *       Ret:   ROK
2459 *
2460 *       Notes: None.
2461 *
2462 *       File:  cm_gen.c
2463 *
2464 */
2465 #ifdef ANSI
2466 PUBLIC S16 cmUnpkPst
2467 (
2468 Pst *pst,
2469 Buffer *mBuf
2470 )
2471 #else
2472 PUBLIC S16 cmUnpkPst(pst, mBuf)
2473 Pst *pst;
2474 Buffer *mBuf;
2475 #endif
2476 {
2477    TRC2(cmUnpkPst)
2478
2479 #ifdef TDS_ROLL_UPGRADE_SUPPORT
2480    CMCHKUNPK(cmUnpkIntfVer, &pst->intfVer, mBuf);
2481 #endif
2482    CMCHKUNPK(cmUnpkSelector, &pst->selector, mBuf); 
2483    CMCHKUNPK(cmUnpkRegion, &pst->region, mBuf); 
2484    CMCHKUNPK(cmUnpkPool, &pst->pool, mBuf); 
2485    CMCHKUNPK(cmUnpkPrior, &pst->prior, mBuf); 
2486    CMCHKUNPK(cmUnpkRoute, &pst->route, mBuf); 
2487    CMCHKUNPK(cmUnpkProcId, &pst->dstProcId, mBuf); 
2488    CMCHKUNPK(cmUnpkEnt, &pst->dstEnt, mBuf); 
2489    CMCHKUNPK(cmUnpkInst, &pst->dstInst, mBuf); 
2490    CMCHKUNPK(cmUnpkProcId, &pst->srcProcId, mBuf); 
2491    CMCHKUNPK(cmUnpkEnt, &pst->srcEnt, mBuf); 
2492    CMCHKUNPK(cmUnpkInst, &pst->srcInst, mBuf); 
2493    CMCHKUNPK(cmUnpkEvent, &pst->event, mBuf);
2494
2495    RETVALUE(ROK);
2496 } /* end of cmUnpkPst */
2497
2498 /*
2499 *
2500 *       Fun:    cmUnpkElmtHdr
2501 *
2502 *       Desc:   Unpack element header
2503 *
2504 *       Ret:   ROK      - ok
2505 *
2506 *       Notes:  None
2507 *
2508 *       File:   cm_gen.c
2509 *
2510 */
2511   
2512 #ifdef ANSI
2513 PUBLIC S16 cmUnpkElmtHdr
2514 (
2515 ElmtHdr *m,                  /* element header */
2516 Buffer  *mBuf                /* message buffer */
2517 )
2518 #else
2519 PUBLIC S16 cmUnpkElmtHdr(m, mBuf)
2520 ElmtHdr *m;                  /* element header */
2521 Buffer  *mBuf;               /* message buffer */
2522 #endif
2523 {
2524    TRC2(cmUnpElmtHdr)
2525  
2526    /* Present */
2527    CMCHKUNPK(cmUnpkBool, &m->pres , mBuf);
2528
2529 #if (LCAMT || ATM_BISUP)
2530    /* Unpack action indicator field */
2531    if (m->pres)
2532    {
2533       CMCHKUNPK(SUnpkU8, &m->actnInd, mBuf);
2534    }
2535 #endif
2536
2537 #if (LCAMT || ATM_BISUP)
2538       CMCHKUNPK(SUnpkU16, &m->compInd, mBuf);
2539 #endif /* LCAMT || ATM_BISUP */
2540
2541    RETVALUE(ROK);
2542 } /* end of cmUnpkElmtHdr */
2543
2544 \f
2545 /*
2546 *
2547 *       Fun:   cmUnpkTknU8
2548 *
2549 *       Desc:  This function unpacks a token U8
2550 *
2551 *       Ret:   ROK      - ok
2552 *
2553 *       Notes: None
2554 *
2555 *       File:  cm_gen.c
2556 *
2557 */
2558   
2559 #ifdef ANSI
2560 PUBLIC S16 cmUnpkTknU8
2561 (
2562 TknU8 *tknU8,               /* token U8 */
2563 Buffer *mBuf                /* message buffer */
2564 )
2565 #else
2566 PUBLIC S16 cmUnpkTknU8(tknU8, mBuf)
2567 TknU8 *tknU8;               /* token U8 */
2568 Buffer *mBuf;               /* message buffer */
2569 #endif
2570 {
2571    TRC2(cmUnpTknU8)
2572
2573    /* Token Header */
2574    CMCHKUNPK(SUnpkU8, &tknU8->pres, mBuf);
2575
2576    if (tknU8->pres)
2577    {
2578       /* Value */
2579       CMCHKUNPK(SUnpkU8, &tknU8->val, mBuf);
2580    }
2581
2582    RETVALUE(ROK);
2583 } /* end of cmUnpkTknU8 */
2584
2585 \f
2586 /*
2587 *
2588 *       Fun:   cmUnpkTknS8
2589 *
2590 *       Desc:  This function unpacks a token S8
2591 *
2592 *       Ret:   ROK      - ok
2593 *
2594 *       Notes: None
2595 *
2596 *       File:  cm_gen.c
2597 *
2598 */
2599   
2600 #ifdef ANSI
2601 PUBLIC S16 cmUnpkTknS8
2602 (
2603 TknS8 *tknS8,               /* token S8 */
2604 Buffer *mBuf                /* message buffer */
2605 )
2606 #else
2607 PUBLIC S16 cmUnpkTknS8(tknS8, mBuf)
2608 TknS8 *tknS8;               /* token S8 */
2609 Buffer *mBuf;               /* message buffer */
2610 #endif
2611 {
2612    TRC2(cmUnpTknS8)
2613  
2614    /* Token Header */
2615    CMCHKUNPK(SUnpkU8, &tknS8->pres, mBuf);
2616  
2617    if (tknS8->pres)
2618    {
2619       /* Value */
2620       CMCHKUNPK(SUnpkS8, &tknS8->val, mBuf);
2621    }
2622  
2623    RETVALUE(ROK);
2624 } /* end of cmUnpkTknS8 */
2625
2626 \f
2627 /*
2628 *
2629 *       Fun:   cmUnpkTknU16
2630 *
2631 *       Desc:  This function unpacks a token U16
2632 *
2633 *       Ret:   ROK      - ok
2634 *
2635 *       Notes: None
2636 *
2637 *       File:  cm_gen.c
2638 *
2639 */
2640   
2641 #ifdef ANSI
2642 PUBLIC S16 cmUnpkTknU16
2643 (
2644 TknU16 *tknU16,             /* token U16 */
2645 Buffer *mBuf                /* message buffer */
2646 )
2647 #else
2648 PUBLIC S16 cmUnpkTknU16(tknU16, mBuf)
2649 TknU16 *tknU16;             /* token U16 */
2650 Buffer *mBuf;               /* message buffer */
2651 #endif
2652 {
2653    TRC2(cmUnpTknU16)
2654
2655    /* Token Header */
2656    CMCHKUNPK(SUnpkU8, &tknU16->pres, mBuf);
2657
2658    if (tknU16->pres)
2659    {
2660       /* Value */
2661       CMCHKUNPK(SUnpkU16, &tknU16->val, mBuf);
2662    }
2663
2664    RETVALUE(ROK);
2665 } /* end of cmUnpkTknU16 */
2666
2667 \f
2668 /*
2669 *
2670 *       Fun:   cmUnpkTknU32
2671 *
2672 *       Desc:  This function unpacks a token U32
2673 *
2674 *       Ret:   ROK      - ok
2675 *
2676 *       Notes: None
2677 *
2678 *       File:  cm_gen.c
2679 *
2680 */
2681   
2682 #ifdef ANSI
2683 PUBLIC S16 cmUnpkTknU32
2684 (
2685 TknU32 *tknU32,             /* token U32 */
2686 Buffer *mBuf                /* message buffer */
2687 )
2688 #else
2689 PUBLIC S16 cmUnpkTknU32(tknU32, mBuf)
2690 TknU32 *tknU32;             /* token U32 */
2691 Buffer *mBuf;               /* message buffer */
2692 #endif
2693 {
2694    TRC2(cmUnpTknU32)
2695
2696    /* Token Header */
2697    CMCHKUNPK(SUnpkU8, &tknU32->pres, mBuf);
2698
2699    if (tknU32->pres)
2700    {
2701       /* Value */
2702       CMCHKUNPK(SUnpkU32, &tknU32->val, mBuf);
2703    }
2704
2705    RETVALUE(ROK);
2706 } /* end of cmUnpkTknU32 */
2707
2708 /*
2709 *
2710 *       Fun:   cmUnpkTknStr
2711 *
2712 *       Desc:  This function unpacks a token string - regular size
2713 *
2714 *       Ret:   ROK      - ok
2715 *
2716 *       Notes: None
2717 *
2718 *       File:  cm_gen.c
2719 *
2720 */
2721   
2722 #ifdef ANSI
2723 PUBLIC S16 cmUnpkTknStr
2724 (
2725 TknStr *tknStr,             /* token string */
2726 Buffer *mBuf                /* message buffer */
2727 )
2728 #else
2729 PUBLIC S16 cmUnpkTknStr(tknStr, mBuf)
2730 TknStr *tknStr;             /* token string */
2731 Buffer *mBuf;               /* message buffer */
2732 #endif
2733 {
2734    Cntr i;                     /* counter */
2735
2736    TRC2(cmUnpTknStr)
2737
2738    /* Token Header */
2739    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
2740
2741    if (tknStr->pres)
2742    {
2743       /* Length */
2744       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
2745
2746       /* Value */
2747       for (i = (tknStr->len - 1); i >= 0; i--)
2748       {
2749          CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
2750       }
2751    }
2752    else
2753       tknStr->len = 0;
2754
2755    RETVALUE(ROK);
2756 } /* end of cmUnpkTknStr */
2757
2758 /*
2759 *
2760 *       Fun:   cmUnpkTknStrM
2761 *
2762 *       Desc:  This function unpacks a token string - medium size
2763 *
2764 *       Ret:   ROK      - ok
2765 *
2766 *       Notes: None
2767 *
2768 *       File:  cm_gen.c
2769 *
2770 */
2771   
2772 #ifdef ANSI
2773 PUBLIC S16 cmUnpkTknStrM
2774 (
2775 TknStrM *tknStr,             /* token string */
2776 Buffer *mBuf                /* message buffer */
2777 )
2778 #else
2779 PUBLIC S16 cmUnpkTknStrM(tknStr, mBuf)
2780 TknStrM *tknStr;             /* token string */
2781 Buffer *mBuf;               /* message buffer */
2782 #endif
2783 {
2784    Cntr i;                     /* counter */
2785
2786    TRC2(cmUnpTknStrM)
2787
2788    /* Token Header */
2789    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
2790
2791    if (tknStr->pres)
2792    {
2793       /* Length */
2794       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
2795
2796       /* Value */
2797       for (i = (tknStr->len - 1); i >= 0; i--)
2798       {
2799          CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
2800       }
2801    }
2802    else
2803       tknStr->len = 0;
2804
2805    RETVALUE(ROK);
2806 } /* end of cmUnpkTknStrM */
2807
2808 \f
2809 /*
2810 *
2811 *       Fun:   cmUnpkTknStrS
2812 *
2813 *       Desc:  This function unpacks a token string - small size
2814 *
2815 *       Ret:   ROK      - ok
2816 *
2817 *       Notes: None
2818 *
2819 *       File:  cm_gen.c
2820 *
2821 */
2822   
2823 #ifdef ANSI
2824 PUBLIC S16 cmUnpkTknStrS
2825 (
2826 TknStrS *tknStr,             /* token string */
2827 Buffer *mBuf                /* message buffer */
2828 )
2829 #else
2830 PUBLIC S16 cmUnpkTknStrS(tknStr, mBuf)
2831 TknStrS *tknStr;             /* token string */
2832 Buffer *mBuf;               /* message buffer */
2833 #endif
2834 {
2835    Cntr i;                     /* counter */
2836
2837    TRC2(cmUnpTknStrS)
2838
2839    /* Token Header */
2840    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
2841
2842    if (tknStr->pres)
2843    {
2844       /* Length */
2845       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
2846
2847       /* Value */
2848       for (i = (tknStr->len - 1); i >= 0; i--)
2849       {
2850          CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
2851       }
2852    }
2853    else
2854       tknStr->len = 0;
2855
2856    RETVALUE(ROK);
2857 } /* end of cmUnpkTknStrS */
2858
2859 \f
2860 /*
2861 *
2862 *       Fun:   cmUnpkTknStrE
2863 *
2864 *       Desc:  This function unpacks a token string - extended size
2865 *
2866 *       Ret:   ROK      - ok
2867 *
2868 *       Notes: None
2869 *
2870 *       File:  cm_gen.c
2871 *
2872 */
2873   
2874 #ifdef ANSI
2875 PUBLIC S16 cmUnpkTknStrE
2876 (
2877 TknStrE *tknStr,             /* token string */
2878 Buffer *mBuf                /* message buffer */
2879 )
2880 #else
2881 PUBLIC S16 cmUnpkTknStrE(tknStr, mBuf)
2882 TknStrE *tknStr;             /* token string */
2883 Buffer *mBuf;               /* message buffer */
2884 #endif
2885 {
2886    Cntr i;                     /* counter */
2887
2888    TRC2(cmUnpTknStrE)
2889
2890    /* Token Header */
2891    CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
2892
2893    if (tknStr->pres)
2894    {
2895       /* Length */
2896       CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
2897
2898       /* Value */
2899       for (i = (tknStr->len - 1); i >= 0; i--)
2900       {
2901          CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
2902       }
2903    }
2904    else
2905       tknStr->len = 0;
2906
2907    RETVALUE(ROK);
2908 } /* end of cmUnpkTknStrE */
2909
2910 #ifndef CMFILE_REORG_1
2911
2912 \f
2913 /*
2914 *
2915 *       Fun:   cmUnpkPnNodeId
2916 *
2917 *       Desc:  This function unpacks a PnNodeId structure from a buffer
2918 *
2919 *       Ret:   Void
2920 *
2921 *       Notes: None
2922 *
2923 *       File:  cm_gen.c
2924 *
2925 */
2926   
2927 #ifdef ANSI
2928 PUBLIC S16 cmUnpkPnNodeId
2929 (
2930 PnNodeId  *dst,     /* source PNNI Node Id */
2931 Buffer *mBuf        /* message buffer */
2932 )
2933 #else
2934 PUBLIC S16 cmUnpkPnNodeId (dst, mBuf)
2935 PnNodeId  *dst;     /* source PNNI Node Id */
2936 Buffer *mBuf;       /* message buffer */
2937 #endif
2938 {
2939    S16 i;
2940    
2941    TRC3(cmUnpkPnNodeId);
2942    
2943    for (i = 0; i < PN_NODEID_LEN; i++)
2944    {
2945       CMCHKUNPK(SUnpkU8, &dst->id[i], mBuf);
2946    }
2947    
2948    RETVALUE(ROK);
2949 } /* cmUnpkPnNodeId */
2950
2951 #endif /* CMFILE_REORG_1 */
2952
2953 \f
2954 /*
2955  *
2956  *      Fun:   cmUnpkTknStr4
2957  *
2958  *      Desc:  This function packs a token string of size 4
2959  *
2960  *      Ret:   ROK      - ok
2961  *
2962  *      Notes: None
2963  *
2964         File:  cm_gen.c
2965  *
2966  */
2967   
2968 #ifdef ANSI
2969 PUBLIC S16 cmUnpkTknStr4
2970 (
2971 TknStr4 *tknStr,             /* token string */
2972 Buffer  *mBuf                /* message buffer */
2973 )
2974 #else
2975 PUBLIC S16 cmUnpkTknStr4(tknStr, mBuf)
2976 TknStr4 *tknStr;             /* token string */
2977 Buffer  *mBuf;               /* message buffer */
2978 #endif
2979 {
2980    TRC2(cmUnpkTknStr4)
2981
2982    CMUNPKTKNSTR(tknStr, mBuf);
2983
2984    RETVALUE(ROK);
2985
2986 } /* end of cmUnpkTknStr4 */
2987
2988
2989 \f
2990 /*
2991  *
2992  *      Fun:   cmUnpkTknStr12
2993  *
2994  *      Desc:  This function packs a token string of size 4
2995  *
2996  *      Ret:   ROK      - ok
2997  *
2998  *      Notes: None
2999  *
3000         File:  cm_gen.c
3001  *
3002  */
3003   
3004 #ifdef ANSI
3005 PUBLIC S16 cmUnpkTknStr12
3006 (
3007 TknStr12 *tknStr,             /* token string */
3008 Buffer   *mBuf                /* message buffer */
3009 )
3010 #else
3011 PUBLIC S16 cmUnpkTknStr12(tknStr, mBuf)
3012 TknStr12 *tknStr;             /* token string */
3013 Buffer   *mBuf;               /* message buffer */
3014 #endif
3015 {
3016    TRC2(cmUnpkTknStr12)
3017
3018    CMUNPKTKNSTR(tknStr, mBuf);
3019
3020    RETVALUE(ROK);
3021
3022 } /* end of cmUnpkTknStr12 */
3023
3024 \f
3025 /*
3026  *
3027  *      Fun:   cmUnpkTknStr32
3028  *
3029  *      Desc:  This function packs a token string of size 4
3030  *
3031  *      Ret:   ROK      - ok
3032  *
3033  *      Notes: None
3034  *
3035         File:  cm_gen.c
3036  *
3037  */
3038   
3039 #ifdef ANSI
3040 PUBLIC S16 cmUnpkTknStr32
3041 (
3042 TknStr32 *tknStr,             /* token string */
3043 Buffer   *mBuf                /* message buffer */
3044 )
3045 #else
3046 PUBLIC S16 cmUnpkTknStr32(tknStr, mBuf)
3047 TknStr32 *tknStr;             /* token string */
3048 Buffer   *mBuf;               /* message buffer */
3049 #endif
3050 {
3051    TRC2(cmUnpkTknStr32)
3052
3053    CMUNPKTKNSTR(tknStr, mBuf);
3054
3055    RETVALUE(ROK);
3056
3057 } /* end of cmUnpkTknStr32 */
3058
3059 \f
3060 /*
3061  *
3062  *      Fun:   cmUnpkTknStr64
3063  *
3064  *      Desc:  This function packs a token string of size 4
3065  *
3066  *      Ret:   ROK      - ok
3067  *
3068  *      Notes: None
3069  *
3070         File:  cm_gen.c
3071  *
3072  */
3073   
3074 #ifdef ANSI
3075 PUBLIC S16 cmUnpkTknStr64
3076 (
3077 TknStr64 *tknStr,             /* token string */
3078 Buffer   *mBuf                /* message buffer */
3079 )
3080 #else
3081 PUBLIC S16 cmUnpkTknStr64(tknStr, mBuf)
3082 TknStr64 *tknStr;             /* token string */
3083 Buffer   *mBuf;               /* message buffer */
3084 #endif
3085 {
3086    TRC2(cmUnpkTknStr64)
3087
3088    CMUNPKTKNSTR(tknStr, mBuf);
3089
3090    RETVALUE(ROK);
3091
3092 } /* end of cmUnpkTknStr64 */
3093
3094 \f
3095 /*
3096  *
3097  *      Fun:   cmUnpkTknStr132
3098  *
3099  *      Desc:  This function packs a token string of size 4
3100  *
3101  *      Ret:   ROK      - ok
3102  *
3103  *      Notes: None
3104  *
3105         File:  cm_gen.c
3106  *
3107  */
3108   
3109 #ifdef ANSI
3110 PUBLIC S16 cmUnpkTknStr132
3111 (
3112 TknStr132 *tknStr,             /* token string */
3113 Buffer   *mBuf                /* message buffer */
3114 )
3115 #else
3116 PUBLIC S16 cmUnpkTknStr132(tknStr, mBuf)
3117 TknStr132 *tknStr;             /* token string */
3118 Buffer   *mBuf;               /* message buffer */
3119 #endif
3120 {
3121    TRC2(cmUnpkTknStr132)
3122
3123    CMUNPKTKNSTR(tknStr, mBuf);
3124
3125    RETVALUE(ROK);
3126
3127 } /* end of cmUnpkTknStr132 */
3128
3129 \f
3130 /*
3131  *
3132  *      Fun:   cmUnpkTknStr256
3133  *
3134  *      Desc:  This function packs a token string of size 4
3135  *
3136  *      Ret:   ROK      - ok
3137  *
3138  *      Notes: None
3139  *
3140         File:  cm_gen.c
3141  *
3142  */
3143   
3144 #ifdef ANSI
3145 PUBLIC S16 cmUnpkTknStr256
3146 (
3147 TknStr256 *tknStr,             /* token string */
3148 Buffer    *mBuf                /* message buffer */
3149 )
3150 #else
3151 PUBLIC S16 cmUnpkTknStr256(tknStr, mBuf)
3152 TknStr256 *tknStr;             /* token string */
3153 Buffer    *mBuf;               /* message buffer */
3154 #endif
3155 {
3156    TRC2(cmUnpkTknStr256)
3157
3158    CMUNPKTKNSTR(tknStr, mBuf);
3159
3160    RETVALUE(ROK);
3161
3162 } /* end of cmUnpkTknStr256 */
3163
3164 \f
3165 /*
3166  *
3167  *      Fun:   cmUnpkTknOid
3168  *
3169  *      Desc:  This function packs a Object Identifier token
3170  *
3171  *      Ret:   ROK      - ok
3172  *
3173  *      Notes: None
3174  *
3175         File:  cm_gen.c
3176  *
3177  */
3178   
3179 #ifdef ANSI
3180 PUBLIC S16 cmUnpkTknOid
3181 (
3182 TknOid   *tknOid,             /* Object Identifier token */
3183 Buffer   *mBuf                /* message buffer */
3184 )
3185 #else
3186 PUBLIC S16 cmUnpkTknOid(tknOid, mBuf)
3187 TknOid   *tknOid;             /* Object Identifier token */
3188 Buffer   *mBuf;               /* message buffer */
3189 #endif
3190 {
3191    U16    i;
3192
3193    TRC2(cmUnpkTknOid)
3194  
3195    /* Unpack the token header */
3196    CMCHKUNPK(SUnpkU8, &tknOid->pres, mBuf);
3197
3198    if (tknOid->pres == TRUE)
3199    {
3200       /* Unpack the length */
3201       CMCHKUNPK(SUnpkU8, &tknOid->len, mBuf);
3202
3203       /* Pack the value */
3204       for (i = 1; i <= (U16)tknOid->len; i++)
3205       {
3206          /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
3207           * with compilation flag TKNOID_U16 */
3208 #ifndef TKNOID_U16
3209          CMCHKUNPK(SUnpkU32, &tknOid->val[tknOid->len - i], mBuf);
3210 #else
3211          CMCHKUNPK(SUnpkU16, &tknOid->val[tknOid->len - i], mBuf);
3212 #endif /* !TKNOID_U16 */
3213       }
3214    }
3215
3216    RETVALUE(ROK);
3217 } /* end of cmUnpkTknOid */
3218
3219 \f
3220 /*
3221 *
3222 *       Fun:   cmUnpkTknS32
3223 *
3224 *       Desc:  This function unpacks a token S32
3225 *
3226 *       Ret:   ROK      - ok
3227 *
3228 *       Notes: None
3229 *
3230 *       File:  cm_gen.c
3231 *
3232 */
3233   
3234 #ifdef ANSI
3235 PUBLIC S16 cmUnpkTknS32
3236 (
3237 TknS32 *tknS32,             /* token S32 */
3238 Buffer *mBuf                /* message buffer */
3239 )
3240 #else
3241 PUBLIC S16 cmUnpkTknS32(tknS32, mBuf)
3242 TknS32 *tknS32;             /* token S32 */
3243 Buffer *mBuf;               /* message buffer */
3244 #endif
3245 {
3246    TRC2(cmUnpTknS32)
3247
3248    /* Token Header */
3249    CMCHKUNPK(SUnpkU8, &tknS32->pres, mBuf);
3250
3251    if (tknS32->pres)
3252    {
3253       /* Value */
3254       CMCHKUNPK(SUnpkS32, &tknS32->val, mBuf);
3255    }
3256
3257    RETVALUE(ROK);
3258 } /* end of cmUnpkTknS32 */
3259
3260 \f
3261 /*
3262 *
3263 *       Fun:   cmUnpkHeader
3264 *
3265 *       Desc:  This function is used to Unpack Header structure
3266 *
3267 *       Ret:   ROK      - ok
3268 *
3269 *       Notes: None.
3270 *
3271 *       File:  cm_gen.c
3272 *
3273 */
3274   
3275 #ifdef ANSI
3276 PUBLIC S16 cmUnpkHeader
3277 (
3278 Header *header,   /* header structure */
3279 Buffer *mBuf      /* message buffer */
3280 )
3281 #else
3282 PUBLIC S16 cmUnpkHeader(header, mBuf)
3283 Header *header;   /* header structure */
3284 Buffer *mBuf;     /* message buffer */
3285 #endif
3286 {
3287    TRC2(cmUnpHeader)
3288
3289    CMCHKUNPK(SUnpkU16, &header->msgLen, mBuf); 
3290    CMCHKUNPK(SUnpkU8, &header->msgType, mBuf); 
3291    CMCHKUNPK(SUnpkU8, &header->version, mBuf); 
3292    CMCHKUNPK(SUnpkU16, &header->seqNmb, mBuf); 
3293    CMCHKUNPK(cmUnpkEntityId, &header->entId, mBuf);    
3294    CMCHKUNPK(cmUnpkElmntId, &header->elmId, mBuf);
3295 #ifdef LMINT3
3296    CMCHKUNPK(cmUnpkTranId, &header->transId, mBuf);
3297    CMCHKUNPK(cmUnpkSelector, &header->response.selector, mBuf);
3298    CMCHKUNPK(cmUnpkPriority, &header->response.prior, mBuf);
3299    CMCHKUNPK(cmUnpkRoute, &header->response.route, mBuf);
3300    CMCHKUNPK(cmUnpkMemoryId, &header->response.mem, mBuf);
3301 #endif /* LMINT3 */
3302
3303    RETVALUE(ROK);
3304 } /* end of cmUnpkHeader */
3305
3306 \f
3307 /*
3308 *
3309 *       Fun:   cmUnpkCmStatus
3310 *
3311 *       Desc:  This function unpacks common management status structure
3312 *
3313 *       Ret:   ROK      - ok
3314 *
3315 *       Notes: None.
3316 *
3317 *       File:  cm_gen.c
3318 *
3319 */
3320   
3321 #ifdef ANSI
3322 PUBLIC S16 cmUnpkCmStatus
3323 (
3324 CmStatus *sta,              /* status structure */
3325 Buffer *mBuf                /* message buffer */
3326 )
3327 #else
3328 PUBLIC S16 cmUnpkCmStatus(sta, mBuf)
3329 CmStatus *sta;              /* status structure */
3330 Buffer *mBuf;               /* message buffer */
3331 #endif
3332 {
3333    TRC2(cmUnpkCmStatus)
3334
3335    CMCHKUNPK(SUnpkU16, &sta->status, mBuf);
3336    CMCHKUNPK(SUnpkU16, &sta->reason, mBuf);
3337
3338    RETVALUE(ROK);
3339 } /* end of cmUnpkCmStatus */
3340
3341 \f
3342 /*
3343 *
3344 *       Fun:   cmUnpkCmAlarm
3345 *
3346 *       Desc:  This function unpacks common management alarm structure
3347 *
3348 *       Ret:   ROK      - ok
3349 *
3350 *       Notes: None.
3351 *
3352 *       File:  cm_gen.c
3353 *
3354 */
3355   
3356 #ifdef ANSI
3357 PUBLIC S16 cmUnpkCmAlarm
3358 (
3359 CmAlarm *alarm,             /* alarm structure */
3360 Buffer *mBuf                /* message buffer */
3361 )
3362 #else
3363 PUBLIC S16 cmUnpkCmAlarm(alarm, mBuf)
3364 CmAlarm *alarm;             /* alarm structure */
3365 Buffer *mBuf;               /* message buffer */
3366 #endif
3367 {
3368    TRC2(cmUnpkCmAlarm)
3369
3370    CMCHKUNPK(cmUnpkDateTime, &alarm->dt, mBuf);
3371    CMCHKUNPK(SUnpkU16, &alarm->category, mBuf);
3372    CMCHKUNPK(SUnpkU16, &alarm->event, mBuf);
3373    CMCHKUNPK(SUnpkU16, &alarm->cause, mBuf);
3374
3375    RETVALUE(ROK);
3376 } /* end of cmUnpkCmAlarm */
3377
3378 \f
3379 /*
3380 *
3381 *       Fun:   cmUnpkSmCfg
3382 *
3383 *       Desc:  This function unpacks the stack manager structure
3384 *
3385 *       Ret:   ROK      - ok
3386 *
3387 *       Notes: None.
3388 *
3389 *       File:  cm_gen.c
3390 *
3391 */
3392   
3393 #ifdef ANSI
3394 PUBLIC S16 cmUnpkSmCfg
3395 (
3396 SmCfg *smCfg,           /* stack manager */
3397 Buffer *mBuf            /* message buffer */
3398 )
3399 #else
3400 PUBLIC S16 cmUnpkSmCfg(smCfg, mBuf)
3401 SmCfg *smCfg;           /* stack manager */
3402 Buffer *mBuf;           /* message buffer */
3403 #endif
3404 {
3405    TRC2(cmUnpSmCfg)
3406
3407    CMCHKUNPK(cmUnpkEnt, &smCfg->ent, mBuf); 
3408    CMCHKUNPK(cmUnpkInst, &smCfg->inst, mBuf); 
3409    CMCHKUNPK(cmUnpkRegion, &smCfg->region, mBuf); 
3410    CMCHKUNPK(cmUnpkPool, &smCfg->pool, mBuf); 
3411    CMCHKUNPK(cmUnpkPrior, &smCfg->prior, mBuf); 
3412    CMCHKUNPK(cmUnpkRoute, &smCfg->route, mBuf); 
3413    CMCHKUNPK(cmUnpkSelector, &smCfg->selector, mBuf);
3414
3415    RETVALUE(ROK);
3416 } /* end of cmUnpkSmCfg */
3417
3418 \f
3419 /*
3420 *
3421 *       Fun:   cmUnpkTmrCfg
3422 *
3423 *       Desc:  This function unpacks the timer configuration structure
3424 *
3425 *       Ret:   ROK      - ok
3426 *
3427 *       Notes: None.
3428 *
3429 *       File:  cm_gen.c
3430 *
3431 */
3432   
3433 #ifdef ANSI
3434 PUBLIC S16 cmUnpkTmrCfg
3435 (
3436 TmrCfg *tmrCfg,         /* timer configuration */
3437 Buffer *mBuf            /* message buffer */
3438 )
3439 #else
3440 PUBLIC S16 cmUnpkTmrCfg(tmrCfg, mBuf)
3441 TmrCfg *tmrCfg;         /* timer configuration */
3442 Buffer *mBuf;           /* message buffer */
3443 #endif
3444 {
3445    TRC2(cmUnpTmrCfg)
3446
3447    CMCHKUNPK(cmUnpkBool, &tmrCfg->enb, mBuf); 
3448    CMCHKUNPK(SUnpkU16, &tmrCfg->val, mBuf);
3449
3450    RETVALUE(ROK);
3451 } /* end of cmUnpkTmrCfg */
3452
3453 /*
3454  *
3455  *      Fun:   cmUnpkTknBuf
3456  *
3457  *      Desc:  This function unpacks a token buffer
3458  *
3459  *      Ret:   ROK      - ok
3460  *
3461  *      Notes: None
3462  *
3463         File:  cm_gen.c
3464  *
3465  */
3466
3467 #ifdef ANSI
3468 PUBLIC S16 cmUnpkTknBuf
3469 (
3470 TknBuf *tknBuf,                /* token string */
3471 Buffer    **tBuf                /* message buffer */
3472 )
3473 #else
3474 PUBLIC S16 cmUnpkTknBuf(tknBuf, tBuf)
3475 TknBuf *tknBuf;                /* token string */
3476 Buffer    **tBuf;               /* message buffer */
3477 #endif
3478 {
3479    Buffer *mBuf;
3480
3481
3482    TRC2(cmUnpkTknBuf)
3483
3484    mBuf = *tBuf;
3485   
3486    /* Token Header */
3487    CMCHKUNPK(SUnpkU8, &tknBuf->pres, mBuf);
3488
3489    if(tknBuf->pres)
3490    {
3491       MsgLen msgLen, buflen;
3492       Region region;                 /* region */
3493       Pool   pool;                   /* pool */
3494
3495       cmUnpkMsgLen(&msgLen, mBuf);
3496       SFndLenMsg(mBuf, &buflen);
3497       if (buflen > msgLen)
3498       {
3499          if( SSegMsg(mBuf, msgLen, &tknBuf->val) != ROK )
3500          {
3501             RETVALUE(RFAILED);
3502          }
3503       }
3504       else
3505       {
3506           /* Allocate the buffer for tknbuf->val */
3507           SGetBufRegionPool(mBuf, &region, &pool);
3508           SGetMsg(region, pool, &(tknBuf->val));
3509       }
3510       
3511      /* now Swap the two Buffer pointers */
3512       SSwapMsg(mBuf,tknBuf->val);
3513       
3514    }
3515
3516    *tBuf = mBuf;
3517
3518    RETVALUE(ROK);
3519 } /* end of cmUnpkTknBuf */
3520
3521 #ifdef TDS_ROLL_UPGRADE_SUPPORT
3522 /*
3523 *
3524 *       Fun:   cmUnpkIntf
3525 *
3526 *       Desc:  This function unpacks the interface information
3527 *
3528 *       Ret:   ROK      - ok
3529 *
3530 *       Notes: None.
3531 *
3532 *       File:  cm_gen.c
3533 *
3534 */
3535   
3536 #ifdef ANSI
3537 PUBLIC S16 cmUnpkIntf
3538 (
3539 CmIntf *intf,           /* interface info */
3540 Buffer *mBuf            /* message buffer */
3541 )
3542 #else
3543 PUBLIC S16 cmUnpkIntf(intf, mBuf)
3544 CmIntf *intf;           /* interface info */
3545 Buffer *mBuf;           /* message buffer */
3546 #endif
3547 {
3548    TRC2(cmUnpkIntf)
3549
3550    CMCHKUNPK(cmUnpkIntfVer, &intf->intfVer, mBuf); 
3551    CMCHKUNPK(cmUnpkIntfId,  &intf->intfId,  mBuf); 
3552
3553    RETVALUE(ROK);
3554 } /* end of cmUnpkIntf */
3555 #endif /* TDS_ROLL_UPGRADE_SUPPORT */
3556
3557 /*
3558 *
3559 *       Fun:   getTransId
3560 *
3561 *       Desc:  This function return the transaction ID used for interface transactions 
3562 *
3563 *       Ret: gTransId
3564 *
3565 *       File:  cm_gen.c
3566 *
3567 */
3568 U16 getTransId()
3569 {
3570    gTransId = (gTransId%65535) + 1;
3571    return gTransId; 
3572 }
3573 /**********************************************************************
3574          End of file
3575 **********************************************************************/