[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Implementation of onduration timer
[o-du/l2.git] / src / cm / cm_lib.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 /********************************************************************20**
20
21      Name:     common library functions
22   
23      Type:     C source file
24   
25      Desc:     Common functions that are implemented in
26                both a portable and a performance-efficient manner. These
27                functions are selected based on the operating system.
28
29      File:     cm_lib.c
30
31 *********************************************************************21*/
32 \f
33 /***********************************************************************
34  * This file provides memory and string library functions implemented in
35  * one of two ways:
36  *
37  *     1. portable: does not assume library support for any of the functions
38  *                  needed.
39  *
40  *     2. using environment specific: this uses existing library
41  *        functions and is therefore, for an environment where such
42  *        functionality is available and , a more desirable choice!
43  *
44  *  The following functions are available in this file:
45  *
46  *       1. cmMemcpy: copies specified number of octets from one memory
47  *          location to another.
48  *       2. cmMemcmp: compares specified number of octets at one memory
49  *          locaton with the same number from another.
50  *       3. cmMemset: sets specified number of octets starting at given
51  *          memory location with the given value.
52  *       4. cmStrCmp: compares two strings, until the '\0' character is
53  *          encountered.
54  *       5. cmStrncmp: compares two strings, until \0 is encountered or
55  *          until the specified length is exceeded.
56  *       6. cmStrlen: finds length of a string until the \0 character.
57  *
58  *  The following flags are used in this file:
59  *
60  *     1. DONT_USE_SYS_LIB: If defined, this will compile in the portable
61  *        versions of each function in this file. This overrides all other
62  *        flags defined in this file.
63  *
64  *  For the SOLARIS environment:
65  *
66  *     The functionality defined in this file is generally available as library
67  *     functions in the native operating systems' libraries. We have provided
68  *     the functionality using the SOLARIS libraries, in this file.
69  *
70  *     If you want to take advantage of these library functions, all you need
71  *     to do is the following:
72  *
73  *     1. Do not turn on the DONT_USE_SYS_LIB flag.
74  *     2. Turn on the SUNOS51 flag.
75  *
76  *     This, in turn, turns on the following flags
77  *
78  *        1. MEMCPY_AVAIL  : maps cmMemcpy to C library function memcpy
79  *        2. MEMCMP_AVAIL  : maps cmMemcmp to C library function memcmp
80  *        3. MEMSET_AVAIL  : maps cmMemset to C library function memset
81  *        4. STRCMP_AVAIL  : maps cmStrcmp to Strings library function strcmp
82  *        5. STRNCMP_AVAIL : maps cmStrncmp to Strings library function strncmp
83  *        5. STRLEN_AVAIL  : maps cmStrlen to Strings library function strlen
84  *
85  *  For an environment different from SOLARIS:
86  *        
87  *    You will need to modify this file to do more or less the same stuff
88  *    as has been done for Solaris. i.e.
89  *
90  *     1. create a section inside the #ifndef DONT_USE_SYS_LIB section
91  *        similar to the #ifdef SUNOS51 section that:
92  *             1. includes system header files.
93  *             2. defines MEMCPY_AVAIL etc. as needed.
94  *     2. modify code inside functions to make use of the system library
95  *        primitive.
96  *     3. communicate your changes to Trillium so they can be incorporated
97  *        in the next release of this file
98  *
99  *  To add a new library primitive to this file:
100  *     1. it should be implemented in both a portable and environment specific
101  *        manner.
102  *     2. the portable implementation will not be the default
103  *     3. the portable version and the environment specif versions must be
104  *        enclosed in #ifdef XXXXXX_AVAIL
105  *                     <environment specific implementation>
106  *                    #else
107  *                     <portable implementation>
108  *                    #endif
109  *     4. It must be communicated to Trillium so it will be included in the
110  *        next release of the file.
111  *     5. Trillium engineering must have all changes approved by engineering
112  *        management.
113  *     6. Trillium reserves the right to not incorporate any changes submitted
114  *        by customers, if not approved by Trillium engineering management.
115  *     7. Trillium reserves the right to modify code submitted by customers to
116  *        enhance this file.
117  ************************************************************************/
118 \f
119 /*cm_lib_c_001.main_13 - Moved env files inclusion to the top*/
120 #include "envopt.h"        /* environment options */
121 #include "envind.h"        /* environment options */
122 #include "envdep.h"        /* environment options */
123
124 #ifndef DONT_USE_SYS_LIB
125
126 #include <stdio.h>
127 #include <ctype.h>
128 #include <stdlib.h>
129 #include <string.h>
130 #define MEMCPY_AVAIL   1
131 #define MEMCMP_AVAIL   1
132 #define MEMSET_AVAIL   1
133 #define STRCMP_AVAIL   1
134 #define STRNCMP_AVAIL  1
135 #define STRLEN_AVAIL   1
136
137 #else  /* DONT_USE_SYS_LIB */
138 #define MEMCPY_AVAIL   0
139 #define MEMCMP_AVAIL   0
140 #define MEMSET_AVAIL   0
141 #define STRCMP_AVAIL   0
142 #define STRNCMP_AVAIL  0
143 #define STRLEN_AVAIL   0
144 #endif /* not DONT_USE_SYS_LIB */
145
146
147  
148 #include "gen.h"           /* general layer */
149 #include "ssi.h"           /* system services */
150
151 /* header/extern include files (.x) */
152  
153 #include "gen.x"           /* general layer */
154 #include "ssi.x"           /* system services */
155 #include "cm_lib.x"        /* prototypes of primitives in this file */
156
157 #if (ERRCLASS & ERRCLS_DEBUG)
158
159 #define ECMLIBBASE     0
160 #define ECMLIB001      ECMLIBBASE + 1
161 #define ECMLIB002      ECMLIBBASE + 2
162 #define ECMLIB003      ECMLIBBASE + 3
163 #define ECMLIB004      ECMLIBBASE + 4
164 #define ECMLIB005      ECMLIBBASE + 5
165 #define ECMLIB006      ECMLIBBASE + 6
166 #define ECMLIB007      ECMLIBBASE + 7
167
168 #define CMLIBERR(_eCode, _eVal, _eDesc) \
169     SLogError ((Ent) 0, (Inst)0, (ProcId)0, __FILE__, __LINE__, \
170                (ErrCls)ERRCLS_DEBUG, (ErrCode)_eCode, (ErrVal) _eVal, \
171                (Txt *) _eDesc)
172 #else
173 #define CMLIBERR(_eCode, _eVal, _eDesc)
174 #endif
175
176 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
177 Data *startPtr128;
178 Size regMemSize;
179 #endif
180 \f
181 /*
182 *
183 *       Fun:   cmMemcpy
184 *
185 *       Desc:  common primitive to copy a contiguous string of bytes
186 *              optimized for when memcpy is available. It uses memcpy
187 *              when available. Otherwise, copies in a 'for' loop.
188 *
189 *              sets "len" memory locations starting from "tgt" to the values
190 *              of corresponding memory locations starting from "src".
191 *
192 *       Ret:   pointer to target string
193 *
194 *       Notes: None
195 *
196 *       File:  cm_lib.c
197 *
198 */
199 uint8_t *cmMemcpy(uint8_t *tgt,const uint8_t *src,PTR len)
200 {
201    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
202
203 #ifdef MS_MBUF_CORRUPTION /* checking for valid memory address */
204 if ((tgt > startPtr128) && (tgt < (startPtr128+regMemSize)))
205 {
206    if ((*((uint32_t *)(tgt + 4)) == 0xDEADDEAD) || (*((uint32_t *)(tgt + 24)) == 0xDEADDEAD) ||
207       (*((uint32_t *)(tgt + 44)) == 0xDEADDEAD) || (*((uint32_t *)(tgt + 80)) == 0xDEADDEAD))
208    {
209       Data *crashPtr=NULLP;
210       *crashPtr = 9;
211    }
212 }
213 if ((src > startPtr128) && (src < (startPtr128+regMemSize)))
214 {
215    if ((*((uint32_t *)(src + 4)) == 0xDEADDEAD) || (*((uint32_t *)(src + 24)) == 0xDEADDEAD) ||
216       (*((uint32_t *)(src + 44)) == 0xDEADDEAD) || (*((uint32_t *)(src + 80)) == 0xDEADDEAD))
217    {
218       Data *crashPtr=NULLP;
219       *crashPtr = 9;
220    }
221 }
222 #endif 
223 #if (MEMCPY_AVAIL) /* memcpy is available */
224    return ( memcpy(tgt, src, len));
225 #else
226    while (len--)
227       *tgt++ = *src++;
228
229    return (tgt);
230 #endif /* MEMCPY_AVAIL */
231
232 } /* end of cmMemcpy */
233
234 \f
235 /*
236 *
237 *       Fun:   cmMemcmp
238 *
239 *       Desc:  common primitive to compare a contiguous string of bytes
240 *              optimized for when memcmp is available. It uses memcmp
241 *              when available. Otherwise, compares in a 'for' loop.
242 *
243 *       Ret:    < 0 => s1 < s2
244 *               > 0 => s1 > s2
245 *               = 0 => s1 = s2
246 *
247 *       Notes: None
248 *
249 *       File:  cm_lib.c
250 *
251 */
252 S16 cmMemcmp(const uint8_t *s1,const uint8_t *s2,PTR len)
253 {
254    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
255 #if MEMCMP_AVAIL /* memcmp is available */
256    return ((S16) memcmp((const Void *)s1, (const Void *)s2, (size_t)len));
257 #else  /* MEMCMP_AVAIL: memcmp is not available */
258    while (len--)
259    {
260       if (*s1 ^ *s2)
261          return ((S16) (*s1 - *s2));
262       s1++;
263       s2++;
264    }
265    return (0);
266 #endif /* MEMCMP_AVAIL */
267 } /* end of cmMemcmp */
268
269 \f
270 /*
271 *
272 *       Fun:   cmMemset
273 *
274 *       Desc:  common primitive to set a contiguous string of bytes
275 *              with a specified value optimized for when memset is available.
276 *              It uses memset when available. Otherwise, uses a 'for' loop.
277 *
278 *              sets "len" memory locations starting from "str" to the value
279 *              "val".
280
281 *       Ret:   pointer to string
282 *
283 *       Notes: None
284 *
285 *       File:  cm_lib.c
286 *
287 */
288 uint8_t *cmMemset(uint8_t *str,uint8_t val,PTR len)
289 {
290    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
291 #if MS_MBUF_CORRUPTION /* checking for valid memory address */
292 if ((str > startPtr128) && (str < (startPtr128+regMemSize)))
293 {
294    if ((*((uint32_t *)(str + 4)) == 0xDEADDEAD) || (*((uint32_t *)(str + 24)) == 0xDEADDEAD) ||
295       (*((uint32_t *)(str + 44)) == 0xDEADDEAD) || (*((uint32_t *)(str + 80)) == 0xDEADDEAD))
296    {
297       Data *crashPtr=NULLP;
298       *crashPtr = 9;
299    }
300 }
301 #endif
302 #if (MEMSET_AVAIL) /* memset is available */
303    if (val==0)
304    {  
305       bzero((void *)str,(size_t)len);
306    }
307    else
308    {
309       memset(str,val, len);
310    }
311 #else  /* MEMSET_AVAIL: memset is not available */
312    while (len --)
313       *str++ = val;
314
315 #endif /* MEMSET_AVAIL */
316    return (str);
317 } /* end of cmMemset */
318
319 \f
320 /*
321 *
322 *       Fun:   cmStrcmp
323 *
324 *       Desc:  common primitive to compare a contiguous string of characters
325 *              terminated by the '\0' character.
326 *
327 *              when strcmp is available, it uses that. otherwise, it
328 *              compares the strings using a for loop.
329 *
330 *              The following is the "strcmp" description from the SunOS 5.4
331 *              man-page. cmStrcmp follows this.
332 *
333 *             strcmp() compares two strings byte-by-byte, according to the
334 *             ordering  of  your  machine's  character  set.  The function
335 *             returns an integer greater than, equal to, or less  than  0,
336 *             if the string pointed to by s1 is greater than, equal to, or
337 *             less than the string pointed to by s2 respectively. The sign
338 *             of  a non-zero return value is determined by the sign of the
339 *             difference between the values of the  first  pair  of  bytes
340 *             that  differ in the strings being compared.
341 *
342 *             Bytes following a null byte are not compared.
343 *
344 *
345 *       Ret:    < 0 => s1 < s2
346 *               > 0 => s1 > s2
347 *               = 0 => s1 = s2
348 *
349 *       Notes: None
350 *
351 *       File:  cm_lib.c
352 *
353 */
354 S16 cmStrcmp(const uint8_t *s1,const uint8_t *s2)
355 {
356    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
357 #if (STRCMP_AVAIL)
358    return (strcmp((const char *)s1, (const char *)s2));
359 #else   /* STRCMP_AVAIL */
360   
361    while (*s1 && *s2)
362    {
363       if (*s1 ^ *s2)
364          return (*s1 - *s2);
365       s1++;
366       s2++;
367    }
368    return (0);
369 #endif      /* strcmp is not available */
370
371 } /* end of cmStrcmp */
372
373
374 \f
375 /*
376 *
377 *       Fun:   cmStrncmp
378 *
379 *       Desc:  common primitive to compare a contiguous string of characters
380 *              terminated by the '\0' character.
381 *              
382 *              when strncmp is available, it uses that. otherwise, it
383 *              compares the strings using a for loop.
384 *              
385 *              The following is the "strncmp" description from the SunOS 5.4
386 *              man-page. cmStrncmp follows this.
387 *
388 *              strcmp() compares two strings byte-by-byte, according to the
389 *              ordering  of  your  machine's  character  set.  The function
390 *              returns an integer greater than, equal to, or less  than  0,
391 *              if the string pointed to by s1 is greater than, equal to, or
392 *              less than the string pointed to by s2 respectively. The sign
393 *              of  a non-zero return value is determined by the sign of the
394 *              difference between the values of the  first  pair  of  bytes
395 *              that  differ in the strings being compared.  strncmp() makes
396 *              the same comparison but looks  at  a  maximum  of  n  bytes.
397 *              Bytes following a null byte are not compared.
398 *
399 *       Ret:    < 0 => s1 < s2
400 *               > 0 => s1 > s2
401 *               = 0 => s1 = s2
402 *
403 *       Notes: None
404 *
405 *       File:  cm_lib.c
406 *
407 */
408 S16 cmStrncmp
409 (
410 const uint8_t  *s1,
411 const uint8_t  *s2,
412 MsgLen       len /* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
413 )
414 {
415    /*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
416 #if (STRNCMP_AVAIL)
417    return (strncmp((const char *)s1, (const char *)s2, (size_t) len));
418 #else   /* STRNCMP_AVAIL */
419   
420    while (*s1 && *s2 && len--)
421    {
422       if (*s1 ^ *s2)
423          return (*s1 - *s2);
424       s1++;
425       s2++;
426    }
427    return (0);
428 #endif   /* strncmp is not available */
429 } /* end of cmStrncmp */
430
431 \f
432 /*
433 *
434 *       Fun:   cmStrlen
435 *
436 *       Desc:  common primitive to compute the length of a NULL terminated
437 *              string.
438 *              
439 *              when strlen is available, it uses that. otherwise, it
440 *              inspects the string using a for loop.
441 *              
442 *              The following is the "strlen" description from the SunOS 5.4
443 *              man-page. cmStrlen follows this.
444 *
445 *              strlen() returns the number of bytes in s, not including the
446 *              terminating null character.
447 *
448 *       Ret:   length of string
449 *
450 *       Notes: None
451 *
452 *       File:  cm_lib.c
453 *
454 */
455 MsgLen cmStrlen(const uint8_t *s)
456 {
457 #if (STRLEN_AVAIL)
458    /*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
459    return ((MsgLen)strlen((const char *)s));
460 #else   /* STRLEN_AVAIL */
461    MsgLen i;
462   
463    /*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
464
465    for (i = 0; *s; i++, s++);
466    return (i);
467 #endif   /* strlen is not available */
468 } /* end of cmStrlen */
469
470 /**********************************************************************
471          End of file
472 **********************************************************************/