LCOV - code coverage report
Current view: top level - src/utils - os.h (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1401264779 Lines: 30 32 93.8 %
Date: 2014-05-28 Functions: 8 8 100.0 %

          Line data    Source code
       1             : /*
       2             :  * OS specific functions
       3             :  * Copyright (c) 2005-2009, Jouni Malinen <j@w1.fi>
       4             :  *
       5             :  * This software may be distributed under the terms of the BSD license.
       6             :  * See README for more details.
       7             :  */
       8             : 
       9             : #ifndef OS_H
      10             : #define OS_H
      11             : 
      12             : typedef long os_time_t;
      13             : 
      14             : /**
      15             :  * os_sleep - Sleep (sec, usec)
      16             :  * @sec: Number of seconds to sleep
      17             :  * @usec: Number of microseconds to sleep
      18             :  */
      19             : void os_sleep(os_time_t sec, os_time_t usec);
      20             : 
      21             : struct os_time {
      22             :         os_time_t sec;
      23             :         os_time_t usec;
      24             : };
      25             : 
      26             : struct os_reltime {
      27             :         os_time_t sec;
      28             :         os_time_t usec;
      29             : };
      30             : 
      31             : /**
      32             :  * os_get_time - Get current time (sec, usec)
      33             :  * @t: Pointer to buffer for the time
      34             :  * Returns: 0 on success, -1 on failure
      35             :  */
      36             : int os_get_time(struct os_time *t);
      37             : 
      38             : /**
      39             :  * os_get_reltime - Get relative time (sec, usec)
      40             :  * @t: Pointer to buffer for the time
      41             :  * Returns: 0 on success, -1 on failure
      42             :  */
      43             : int os_get_reltime(struct os_reltime *t);
      44             : 
      45             : 
      46             : /* Helpers for handling struct os_time */
      47             : 
      48             : static inline int os_time_before(struct os_time *a, struct os_time *b)
      49             : {
      50             :         return (a->sec < b->sec) ||
      51             :                (a->sec == b->sec && a->usec < b->usec);
      52             : }
      53             : 
      54             : 
      55             : static inline void os_time_sub(struct os_time *a, struct os_time *b,
      56             :                                struct os_time *res)
      57             : {
      58             :         res->sec = a->sec - b->sec;
      59             :         res->usec = a->usec - b->usec;
      60             :         if (res->usec < 0) {
      61             :                 res->sec--;
      62             :                 res->usec += 1000000;
      63             :         }
      64             : }
      65             : 
      66             : 
      67             : /* Helpers for handling struct os_reltime */
      68             : 
      69      501398 : static inline int os_reltime_before(struct os_reltime *a,
      70             :                                     struct os_reltime *b)
      71             : {
      72     1063447 :         return (a->sec < b->sec) ||
      73      323166 :                (a->sec == b->sec && a->usec < b->usec);
      74             : }
      75             : 
      76             : 
      77      182915 : static inline void os_reltime_sub(struct os_reltime *a, struct os_reltime *b,
      78             :                                   struct os_reltime *res)
      79             : {
      80      182915 :         res->sec = a->sec - b->sec;
      81      182915 :         res->usec = a->usec - b->usec;
      82      182915 :         if (res->usec < 0) {
      83      111685 :                 res->sec--;
      84      111685 :                 res->usec += 1000000;
      85             :         }
      86      182915 : }
      87             : 
      88             : 
      89          33 : static inline void os_reltime_age(struct os_reltime *start,
      90             :                                   struct os_reltime *age)
      91             : {
      92             :         struct os_reltime now;
      93             : 
      94          33 :         os_get_reltime(&now);
      95          33 :         os_reltime_sub(&now, start, age);
      96          33 : }
      97             : 
      98             : 
      99         752 : static inline int os_reltime_expired(struct os_reltime *now,
     100             :                                      struct os_reltime *ts,
     101             :                                      os_time_t timeout_secs)
     102             : {
     103             :         struct os_reltime age;
     104             : 
     105         752 :         os_reltime_sub(now, ts, &age);
     106        1505 :         return (age.sec > timeout_secs) ||
     107         748 :                (age.sec == timeout_secs && age.usec > 0);
     108             : }
     109             : 
     110             : 
     111        1850 : static inline int os_reltime_initialized(struct os_reltime *t)
     112             : {
     113        1850 :         return t->sec != 0 || t->usec != 0;
     114             : }
     115             : 
     116             : 
     117             : /**
     118             :  * os_mktime - Convert broken-down time into seconds since 1970-01-01
     119             :  * @year: Four digit year
     120             :  * @month: Month (1 .. 12)
     121             :  * @day: Day of month (1 .. 31)
     122             :  * @hour: Hour (0 .. 23)
     123             :  * @min: Minute (0 .. 59)
     124             :  * @sec: Second (0 .. 60)
     125             :  * @t: Buffer for returning calendar time representation (seconds since
     126             :  * 1970-01-01 00:00:00)
     127             :  * Returns: 0 on success, -1 on failure
     128             :  *
     129             :  * Note: The result is in seconds from Epoch, i.e., in UTC, not in local time
     130             :  * which is used by POSIX mktime().
     131             :  */
     132             : int os_mktime(int year, int month, int day, int hour, int min, int sec,
     133             :               os_time_t *t);
     134             : 
     135             : struct os_tm {
     136             :         int sec; /* 0..59 or 60 for leap seconds */
     137             :         int min; /* 0..59 */
     138             :         int hour; /* 0..23 */
     139             :         int day; /* 1..31 */
     140             :         int month; /* 1..12 */
     141             :         int year; /* Four digit year */
     142             : };
     143             : 
     144             : int os_gmtime(os_time_t t, struct os_tm *tm);
     145             : 
     146             : /**
     147             :  * os_daemonize - Run in the background (detach from the controlling terminal)
     148             :  * @pid_file: File name to write the process ID to or %NULL to skip this
     149             :  * Returns: 0 on success, -1 on failure
     150             :  */
     151             : int os_daemonize(const char *pid_file);
     152             : 
     153             : /**
     154             :  * os_daemonize_terminate - Stop running in the background (remove pid file)
     155             :  * @pid_file: File name to write the process ID to or %NULL to skip this
     156             :  */
     157             : void os_daemonize_terminate(const char *pid_file);
     158             : 
     159             : /**
     160             :  * os_get_random - Get cryptographically strong pseudo random data
     161             :  * @buf: Buffer for pseudo random data
     162             :  * @len: Length of the buffer
     163             :  * Returns: 0 on success, -1 on failure
     164             :  */
     165             : int os_get_random(unsigned char *buf, size_t len);
     166             : 
     167             : /**
     168             :  * os_random - Get pseudo random value (not necessarily very strong)
     169             :  * Returns: Pseudo random value
     170             :  */
     171             : unsigned long os_random(void);
     172             : 
     173             : /**
     174             :  * os_rel2abs_path - Get an absolute path for a file
     175             :  * @rel_path: Relative path to a file
     176             :  * Returns: Absolute path for the file or %NULL on failure
     177             :  *
     178             :  * This function tries to convert a relative path of a file to an absolute path
     179             :  * in order for the file to be found even if current working directory has
     180             :  * changed. The returned value is allocated and caller is responsible for
     181             :  * freeing it. It is acceptable to just return the same path in an allocated
     182             :  * buffer, e.g., return strdup(rel_path). This function is only used to find
     183             :  * configuration files when os_daemonize() may have changed the current working
     184             :  * directory and relative path would be pointing to a different location.
     185             :  */
     186             : char * os_rel2abs_path(const char *rel_path);
     187             : 
     188             : /**
     189             :  * os_program_init - Program initialization (called at start)
     190             :  * Returns: 0 on success, -1 on failure
     191             :  *
     192             :  * This function is called when a programs starts. If there are any OS specific
     193             :  * processing that is needed, it can be placed here. It is also acceptable to
     194             :  * just return 0 if not special processing is needed.
     195             :  */
     196             : int os_program_init(void);
     197             : 
     198             : /**
     199             :  * os_program_deinit - Program deinitialization (called just before exit)
     200             :  *
     201             :  * This function is called just before a program exists. If there are any OS
     202             :  * specific processing, e.g., freeing resourced allocated in os_program_init(),
     203             :  * it should be done here. It is also acceptable for this function to do
     204             :  * nothing.
     205             :  */
     206             : void os_program_deinit(void);
     207             : 
     208             : /**
     209             :  * os_setenv - Set environment variable
     210             :  * @name: Name of the variable
     211             :  * @value: Value to set to the variable
     212             :  * @overwrite: Whether existing variable should be overwritten
     213             :  * Returns: 0 on success, -1 on error
     214             :  *
     215             :  * This function is only used for wpa_cli action scripts. OS wrapper does not
     216             :  * need to implement this if such functionality is not needed.
     217             :  */
     218             : int os_setenv(const char *name, const char *value, int overwrite);
     219             : 
     220             : /**
     221             :  * os_unsetenv - Delete environent variable
     222             :  * @name: Name of the variable
     223             :  * Returns: 0 on success, -1 on error
     224             :  *
     225             :  * This function is only used for wpa_cli action scripts. OS wrapper does not
     226             :  * need to implement this if such functionality is not needed.
     227             :  */
     228             : int os_unsetenv(const char *name);
     229             : 
     230             : /**
     231             :  * os_readfile - Read a file to an allocated memory buffer
     232             :  * @name: Name of the file to read
     233             :  * @len: For returning the length of the allocated buffer
     234             :  * Returns: Pointer to the allocated buffer or %NULL on failure
     235             :  *
     236             :  * This function allocates memory and reads the given file to this buffer. Both
     237             :  * binary and text files can be read with this function. The caller is
     238             :  * responsible for freeing the returned buffer with os_free().
     239             :  */
     240             : char * os_readfile(const char *name, size_t *len);
     241             : 
     242             : /**
     243             :  * os_file_exists - Check whether the specified file exists
     244             :  * @fname: Path and name of the file
     245             :  * Returns: 1 if the file exists or 0 if not
     246             :  */
     247             : int os_file_exists(const char *fname);
     248             : 
     249             : /**
     250             :  * os_zalloc - Allocate and zero memory
     251             :  * @size: Number of bytes to allocate
     252             :  * Returns: Pointer to allocated and zeroed memory or %NULL on failure
     253             :  *
     254             :  * Caller is responsible for freeing the returned buffer with os_free().
     255             :  */
     256             : void * os_zalloc(size_t size);
     257             : 
     258             : /**
     259             :  * os_calloc - Allocate and zero memory for an array
     260             :  * @nmemb: Number of members in the array
     261             :  * @size: Number of bytes in each member
     262             :  * Returns: Pointer to allocated and zeroed memory or %NULL on failure
     263             :  *
     264             :  * This function can be used as a wrapper for os_zalloc(nmemb * size) when an
     265             :  * allocation is used for an array. The main benefit over os_zalloc() is in
     266             :  * having an extra check to catch integer overflows in multiplication.
     267             :  *
     268             :  * Caller is responsible for freeing the returned buffer with os_free().
     269             :  */
     270       17714 : static inline void * os_calloc(size_t nmemb, size_t size)
     271             : {
     272       17714 :         if (size && nmemb > (~(size_t) 0) / size)
     273           0 :                 return NULL;
     274       17714 :         return os_zalloc(nmemb * size);
     275             : }
     276             : 
     277             : 
     278             : /*
     279             :  * The following functions are wrapper for standard ANSI C or POSIX functions.
     280             :  * By default, they are just defined to use the standard function name and no
     281             :  * os_*.c implementation is needed for them. This avoids extra function calls
     282             :  * by allowing the C pre-processor take care of the function name mapping.
     283             :  *
     284             :  * If the target system uses a C library that does not provide these functions,
     285             :  * build_config.h can be used to define the wrappers to use a different
     286             :  * function name. This can be done on function-by-function basis since the
     287             :  * defines here are only used if build_config.h does not define the os_* name.
     288             :  * If needed, os_*.c file can be used to implement the functions that are not
     289             :  * included in the C library on the target system. Alternatively,
     290             :  * OS_NO_C_LIB_DEFINES can be defined to skip all defines here in which case
     291             :  * these functions need to be implemented in os_*.c file for the target system.
     292             :  */
     293             : 
     294             : #ifdef OS_NO_C_LIB_DEFINES
     295             : 
     296             : /**
     297             :  * os_malloc - Allocate dynamic memory
     298             :  * @size: Size of the buffer to allocate
     299             :  * Returns: Allocated buffer or %NULL on failure
     300             :  *
     301             :  * Caller is responsible for freeing the returned buffer with os_free().
     302             :  */
     303             : void * os_malloc(size_t size);
     304             : 
     305             : /**
     306             :  * os_realloc - Re-allocate dynamic memory
     307             :  * @ptr: Old buffer from os_malloc() or os_realloc()
     308             :  * @size: Size of the new buffer
     309             :  * Returns: Allocated buffer or %NULL on failure
     310             :  *
     311             :  * Caller is responsible for freeing the returned buffer with os_free().
     312             :  * If re-allocation fails, %NULL is returned and the original buffer (ptr) is
     313             :  * not freed and caller is still responsible for freeing it.
     314             :  */
     315             : void * os_realloc(void *ptr, size_t size);
     316             : 
     317             : /**
     318             :  * os_free - Free dynamic memory
     319             :  * @ptr: Old buffer from os_malloc() or os_realloc(); can be %NULL
     320             :  */
     321             : void os_free(void *ptr);
     322             : 
     323             : /**
     324             :  * os_memcpy - Copy memory area
     325             :  * @dest: Destination
     326             :  * @src: Source
     327             :  * @n: Number of bytes to copy
     328             :  * Returns: dest
     329             :  *
     330             :  * The memory areas src and dst must not overlap. os_memmove() can be used with
     331             :  * overlapping memory.
     332             :  */
     333             : void * os_memcpy(void *dest, const void *src, size_t n);
     334             : 
     335             : /**
     336             :  * os_memmove - Copy memory area
     337             :  * @dest: Destination
     338             :  * @src: Source
     339             :  * @n: Number of bytes to copy
     340             :  * Returns: dest
     341             :  *
     342             :  * The memory areas src and dst may overlap.
     343             :  */
     344             : void * os_memmove(void *dest, const void *src, size_t n);
     345             : 
     346             : /**
     347             :  * os_memset - Fill memory with a constant byte
     348             :  * @s: Memory area to be filled
     349             :  * @c: Constant byte
     350             :  * @n: Number of bytes started from s to fill with c
     351             :  * Returns: s
     352             :  */
     353             : void * os_memset(void *s, int c, size_t n);
     354             : 
     355             : /**
     356             :  * os_memcmp - Compare memory areas
     357             :  * @s1: First buffer
     358             :  * @s2: Second buffer
     359             :  * @n: Maximum numbers of octets to compare
     360             :  * Returns: An integer less than, equal to, or greater than zero if s1 is
     361             :  * found to be less than, to match, or be greater than s2. Only first n
     362             :  * characters will be compared.
     363             :  */
     364             : int os_memcmp(const void *s1, const void *s2, size_t n);
     365             : 
     366             : /**
     367             :  * os_strdup - Duplicate a string
     368             :  * @s: Source string
     369             :  * Returns: Allocated buffer with the string copied into it or %NULL on failure
     370             :  *
     371             :  * Caller is responsible for freeing the returned buffer with os_free().
     372             :  */
     373             : char * os_strdup(const char *s);
     374             : 
     375             : /**
     376             :  * os_strlen - Calculate the length of a string
     377             :  * @s: '\0' terminated string
     378             :  * Returns: Number of characters in s (not counting the '\0' terminator)
     379             :  */
     380             : size_t os_strlen(const char *s);
     381             : 
     382             : /**
     383             :  * os_strcasecmp - Compare two strings ignoring case
     384             :  * @s1: First string
     385             :  * @s2: Second string
     386             :  * Returns: An integer less than, equal to, or greater than zero if s1 is
     387             :  * found to be less than, to match, or be greatred than s2
     388             :  */
     389             : int os_strcasecmp(const char *s1, const char *s2);
     390             : 
     391             : /**
     392             :  * os_strncasecmp - Compare two strings ignoring case
     393             :  * @s1: First string
     394             :  * @s2: Second string
     395             :  * @n: Maximum numbers of characters to compare
     396             :  * Returns: An integer less than, equal to, or greater than zero if s1 is
     397             :  * found to be less than, to match, or be greater than s2. Only first n
     398             :  * characters will be compared.
     399             :  */
     400             : int os_strncasecmp(const char *s1, const char *s2, size_t n);
     401             : 
     402             : /**
     403             :  * os_strchr - Locate the first occurrence of a character in string
     404             :  * @s: String
     405             :  * @c: Character to search for
     406             :  * Returns: Pointer to the matched character or %NULL if not found
     407             :  */
     408             : char * os_strchr(const char *s, int c);
     409             : 
     410             : /**
     411             :  * os_strrchr - Locate the last occurrence of a character in string
     412             :  * @s: String
     413             :  * @c: Character to search for
     414             :  * Returns: Pointer to the matched character or %NULL if not found
     415             :  */
     416             : char * os_strrchr(const char *s, int c);
     417             : 
     418             : /**
     419             :  * os_strcmp - Compare two strings
     420             :  * @s1: First string
     421             :  * @s2: Second string
     422             :  * Returns: An integer less than, equal to, or greater than zero if s1 is
     423             :  * found to be less than, to match, or be greatred than s2
     424             :  */
     425             : int os_strcmp(const char *s1, const char *s2);
     426             : 
     427             : /**
     428             :  * os_strncmp - Compare two strings
     429             :  * @s1: First string
     430             :  * @s2: Second string
     431             :  * @n: Maximum numbers of characters to compare
     432             :  * Returns: An integer less than, equal to, or greater than zero if s1 is
     433             :  * found to be less than, to match, or be greater than s2. Only first n
     434             :  * characters will be compared.
     435             :  */
     436             : int os_strncmp(const char *s1, const char *s2, size_t n);
     437             : 
     438             : /**
     439             :  * os_strstr - Locate a substring
     440             :  * @haystack: String (haystack) to search from
     441             :  * @needle: Needle to search from haystack
     442             :  * Returns: Pointer to the beginning of the substring or %NULL if not found
     443             :  */
     444             : char * os_strstr(const char *haystack, const char *needle);
     445             : 
     446             : /**
     447             :  * os_snprintf - Print to a memory buffer
     448             :  * @str: Memory buffer to print into
     449             :  * @size: Maximum length of the str buffer
     450             :  * @format: printf format
     451             :  * Returns: Number of characters printed (not including trailing '\0').
     452             :  *
     453             :  * If the output buffer is truncated, number of characters which would have
     454             :  * been written is returned. Since some C libraries return -1 in such a case,
     455             :  * the caller must be prepared on that value, too, to indicate truncation.
     456             :  *
     457             :  * Note: Some C library implementations of snprintf() may not guarantee null
     458             :  * termination in case the output is truncated. The OS wrapper function of
     459             :  * os_snprintf() should provide this guarantee, i.e., to null terminate the
     460             :  * output buffer if a C library version of the function is used and if that
     461             :  * function does not guarantee null termination.
     462             :  *
     463             :  * If the target system does not include snprintf(), see, e.g.,
     464             :  * http://www.ijs.si/software/snprintf/ for an example of a portable
     465             :  * implementation of snprintf.
     466             :  */
     467             : int os_snprintf(char *str, size_t size, const char *format, ...);
     468             : 
     469             : #else /* OS_NO_C_LIB_DEFINES */
     470             : 
     471             : #ifdef WPA_TRACE
     472             : void * os_malloc(size_t size);
     473             : void * os_realloc(void *ptr, size_t size);
     474             : void os_free(void *ptr);
     475             : char * os_strdup(const char *s);
     476             : #else /* WPA_TRACE */
     477             : #ifndef os_malloc
     478             : #define os_malloc(s) malloc((s))
     479             : #endif
     480             : #ifndef os_realloc
     481             : #define os_realloc(p, s) realloc((p), (s))
     482             : #endif
     483             : #ifndef os_free
     484             : #define os_free(p) free((p))
     485             : #endif
     486             : #ifndef os_strdup
     487             : #ifdef _MSC_VER
     488             : #define os_strdup(s) _strdup(s)
     489             : #else
     490             : #define os_strdup(s) strdup(s)
     491             : #endif
     492             : #endif
     493             : #endif /* WPA_TRACE */
     494             : 
     495             : #ifndef os_memcpy
     496             : #define os_memcpy(d, s, n) memcpy((d), (s), (n))
     497             : #endif
     498             : #ifndef os_memmove
     499             : #define os_memmove(d, s, n) memmove((d), (s), (n))
     500             : #endif
     501             : #ifndef os_memset
     502             : #define os_memset(s, c, n) memset(s, c, n)
     503             : #endif
     504             : #ifndef os_memcmp
     505             : #define os_memcmp(s1, s2, n) memcmp((s1), (s2), (n))
     506             : #endif
     507             : 
     508             : #ifndef os_strlen
     509             : #define os_strlen(s) strlen(s)
     510             : #endif
     511             : #ifndef os_strcasecmp
     512             : #ifdef _MSC_VER
     513             : #define os_strcasecmp(s1, s2) _stricmp((s1), (s2))
     514             : #else
     515             : #define os_strcasecmp(s1, s2) strcasecmp((s1), (s2))
     516             : #endif
     517             : #endif
     518             : #ifndef os_strncasecmp
     519             : #ifdef _MSC_VER
     520             : #define os_strncasecmp(s1, s2, n) _strnicmp((s1), (s2), (n))
     521             : #else
     522             : #define os_strncasecmp(s1, s2, n) strncasecmp((s1), (s2), (n))
     523             : #endif
     524             : #endif
     525             : #ifndef os_strchr
     526             : #define os_strchr(s, c) strchr((s), (c))
     527             : #endif
     528             : #ifndef os_strcmp
     529             : #define os_strcmp(s1, s2) strcmp((s1), (s2))
     530             : #endif
     531             : #ifndef os_strncmp
     532             : #define os_strncmp(s1, s2, n) strncmp((s1), (s2), (n))
     533             : #endif
     534             : #ifndef os_strrchr
     535             : #define os_strrchr(s, c) strrchr((s), (c))
     536             : #endif
     537             : #ifndef os_strstr
     538             : #define os_strstr(h, n) strstr((h), (n))
     539             : #endif
     540             : 
     541             : #ifndef os_snprintf
     542             : #ifdef _MSC_VER
     543             : #define os_snprintf _snprintf
     544             : #else
     545             : #define os_snprintf snprintf
     546             : #endif
     547             : #endif
     548             : 
     549             : #endif /* OS_NO_C_LIB_DEFINES */
     550             : 
     551             : 
     552      165554 : static inline void * os_realloc_array(void *ptr, size_t nmemb, size_t size)
     553             : {
     554      165554 :         if (size && nmemb > (~(size_t) 0) / size)
     555           0 :                 return NULL;
     556      165554 :         return os_realloc(ptr, nmemb * size);
     557             : }
     558             : 
     559             : /**
     560             :  * os_remove_in_array - Remove a member from an array by index
     561             :  * @ptr: Pointer to the array
     562             :  * @nmemb: Current member count of the array
     563             :  * @size: The size per member of the array
     564             :  * @idx: Index of the member to be removed
     565             :  */
     566           8 : static inline void os_remove_in_array(void *ptr, size_t nmemb, size_t size,
     567             :                                       size_t idx)
     568             : {
     569           8 :         if (idx < nmemb - 1)
     570           4 :                 os_memmove(((unsigned char *) ptr) + idx * size,
     571             :                            ((unsigned char *) ptr) + (idx + 1) * size,
     572             :                            (nmemb - idx - 1) * size);
     573           8 : }
     574             : 
     575             : /**
     576             :  * os_strlcpy - Copy a string with size bound and NUL-termination
     577             :  * @dest: Destination
     578             :  * @src: Source
     579             :  * @siz: Size of the target buffer
     580             :  * Returns: Total length of the target string (length of src) (not including
     581             :  * NUL-termination)
     582             :  *
     583             :  * This function matches in behavior with the strlcpy(3) function in OpenBSD.
     584             :  */
     585             : size_t os_strlcpy(char *dest, const char *src, size_t siz);
     586             : 
     587             : 
     588             : #ifdef OS_REJECT_C_LIB_FUNCTIONS
     589             : #define malloc OS_DO_NOT_USE_malloc
     590             : #define realloc OS_DO_NOT_USE_realloc
     591             : #define free OS_DO_NOT_USE_free
     592             : #define memcpy OS_DO_NOT_USE_memcpy
     593             : #define memmove OS_DO_NOT_USE_memmove
     594             : #define memset OS_DO_NOT_USE_memset
     595             : #define memcmp OS_DO_NOT_USE_memcmp
     596             : #undef strdup
     597             : #define strdup OS_DO_NOT_USE_strdup
     598             : #define strlen OS_DO_NOT_USE_strlen
     599             : #define strcasecmp OS_DO_NOT_USE_strcasecmp
     600             : #define strncasecmp OS_DO_NOT_USE_strncasecmp
     601             : #undef strchr
     602             : #define strchr OS_DO_NOT_USE_strchr
     603             : #undef strcmp
     604             : #define strcmp OS_DO_NOT_USE_strcmp
     605             : #undef strncmp
     606             : #define strncmp OS_DO_NOT_USE_strncmp
     607             : #undef strncpy
     608             : #define strncpy OS_DO_NOT_USE_strncpy
     609             : #define strrchr OS_DO_NOT_USE_strrchr
     610             : #define strstr OS_DO_NOT_USE_strstr
     611             : #undef snprintf
     612             : #define snprintf OS_DO_NOT_USE_snprintf
     613             : 
     614             : #define strcpy OS_DO_NOT_USE_strcpy
     615             : #endif /* OS_REJECT_C_LIB_FUNCTIONS */
     616             : 
     617             : #endif /* OS_H */

Generated by: LCOV version 1.10