yumapro  23.10T-6
YumaPro SDK
Loading...
Searching...
No Matches
log.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
3 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
4 *
5 * Unless required by applicable law or agreed to in writing,
6 * software distributed under the License is distributed on an
7 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
8 * KIND, either express or implied. See the License for the
9 * specific language governing permissions and limitations
10 * under the License.
11 */
12#ifndef _H_log
13#define _H_log
14/* FILE: log.h
15*********************************************************************
16* *
17* P U R P O S E *
18* *
19*********************************************************************/
20
21
22
30/********************************************************************
31* *
32* C H A N G E H I S T O R Y *
33* *
34*********************************************************************
35
36date init comment
37----------------------------------------------------------------------
3808-jan-06 abb begun
3928may12 mts Logging feature set mods
40*/
41
42
43
44
45#include <stdio.h>
46#include <xmlstring.h>
47
48#include "procdefs.h"
49#include "status.h"
50
51#ifdef PTHREADS
52#ifndef _H_thd
53#include "thd.h"
54#endif
55#endif
56
57#ifdef __cplusplus
58extern "C" {
59#endif
60
61/********************************************************************
62* *
63* M A C R O S *
64* *
65*********************************************************************/
66
67#if defined(_XOPEN_SOURCE) || defined(CYGWIN) || defined(MACOSX)
68#define uint uint32
69#endif
70
71
72/*
73 * Log internal errors to stderr. We can't call logger code to
74 * handle its own internal errors.
75 */
76
77/********************************************************************
78* MACRO: LOG_INTERNAL_ERR
79*
80* Output string to stderr reporting error, function name, and line number
81* and resulting action ...
82*
83* EXAMPLE:
84*
85* MACRO: LOG_INTERNAL_ERR(Null buf ptr, RETURN);
86*
87* OUTPUT: ERROR [log_util_init_buf@86]: Null buf ptr - RETURN
88*
89*
90*********************************************************************/
91#define LOG_INTERNAL_ERR(err_str, action) \
92 log_internal_err("\nERROR [%s@%d]: " #err_str " - " #action, \
93 __FUNCTION__, __LINE__)
94
95#define LOG_INTERNAL_LOCK_ERR(name, err_str, hndl, rc, action) \
96 log_internal_lock_err( \
97 "\nERROR [%s@%d]: [" #name "] " #err_str " (%p:%d) - " #action, \
98 __FUNCTION__, __LINE__, (void *)(hndl), rc)
99
100
101/********************************************************************
102* MACRO: LOG_INTERNAL_BUFF_ERR
103*
104* Output string to stderr reporting error, function name, and line number.
105* Dump salient buffer descriptor state, and resulting action ...
106*
107* EXAMPLE:
108*
109* MACRO: LOG_INTERNAL_BUF_ERR(Bad buf, buf, remaining, REINIT);
110*
111* OUTPUT: ERROR [upd_log_buf@179]: Bad buf 'remaining' [ptr=81783a0, \
112* id=4242, start=81783cc, end=81787cc, len=1024(0x400), \
113* remaining=1024(0x400)]->remaining=400 - REINIT \
114*
115*********************************************************************/
116#define LOG_INTERNAL_BUF_ERR(err_str, ptr, action) \
117 log_internal_err("\nERROR [%s@%d]: " #err_str \
118 " [ptr=%p, id=%4x, start=%p, end=%p" \
119 ", len=%u(0x%x), remaining=%d(0x%x)]" \
120 " wp=%u" " - %s\n", __FUNCTION__, __LINE__, \
121 ptr, (ptr)->idid, (ptr)->start, (ptr)->end, \
122 (ptr)->len, (ptr)->len, (ptr)->remaining, (ptr)->remaining, \
123 (uint)(ptr)->write_pending, #action)
124
125
126/********************************************************************
127* *
128* C O N S T A N T S *
129* *
130*********************************************************************/
131#define LOG_CLEANUP_PHASE1 FALSE
132#define LOG_CLEANUP_PHASE2 !LOG_CLEANUP_PHASE1
133
134
135/********************************************************************
136* MACRO FILTER_DEBUG_LEVEL(lvl)
137*
138* Filter log calls at debug_level and syslog_level.
139*
140* Note: For efficiency, looks first at system_debug_level which is defined
141* to be max of (debug_level, syslog_log_level, pthread_log_level).
142* If system_debug_level indicates filtering, then no need to look
143* at context specific debug levels.
144*
145* Note: pthread_log_level only exists in PTHREAD build
146*
147* INPUTS:
148* lvl == debug level to inspect
149*
150* RETURNS:
151* TRUE => filter
152* FALSE => pass
153*********************************************************************/
154#define FILTER_DEBUG_LEVEL(lvl) \
155 ((log_get_system_log_level() < (lvl)) || \
156 ((log_get_log_level() < (lvl)) && \
157 (log_get_syslog_log_level() < (lvl))))
158
159#define ALLOW_DEBUG_LEVEL(lvl) !FILTER_DEBUG_LEVEL(lvl)
160
161#ifdef PTHREADS
162/********************************************************************
163* MACRO FILTER_PTHREAD_DEBUG_LEVEL(lvl)
164*
165* Filter pthread specific log calls at pthread_debug_level
166*
167* Note: For efficiency, looks first at system_debug_level which is defined
168* to be max of (debug_level, syslog_log_level, pthread_log_level).
169* If system_debug_level indicates filtering, then no need to look
170* at context specific debug levels.
171*
172* Note: pthread_log_level only exists in PTHREAD build
173*
174* INPUTS:
175* lvl == debug level to inspect
176*
177* RETURNS:
178* TRUE => filter
179* FALSE => pass
180*********************************************************************/
181#define FILTER_PTHREAD_DEBUG_LEVEL(lvl) \
182 ((log_get_system_log_level() < (lvl)) || \
183 (log_get_pthread_log_level() < (lvl)))
184
185#define ALLOW_PTHREAD_DEBUG_LEVEL(lvl) !FILTER_PTHREAD_DEBUG_LEVEL(lvl)
186#endif
187
188
189// Header only
190
203#define LOGDEV0 (log_get_system_log_level() >= LOG_DEBUG_DEV0)
204
205 // BEGIN ncxlib/log/logmacros
221
222
223
227#define LOGERROR (log_get_system_log_level() >= LOG_DEBUG_ERROR)
228
232#define LOGWARN (log_get_system_log_level() >= LOG_DEBUG_WARN)
233
237#define LOGINFO (log_get_system_log_level() >= LOG_DEBUG_INFO)
238
239
240#define LOGDEV1 (log_get_system_log_level() >= LOG_DEBUG_DEV1)
241
245#define LOGDEBUG (log_get_system_log_level() >= LOG_DEBUG_DEBUG)
246
250#define LOGDEBUG2 (log_get_system_log_level() >= LOG_DEBUG_DEBUG2)
251
255#define LOGDEBUG3 (log_get_system_log_level() >= LOG_DEBUG_DEBUG3)
256
260#define LOGDEBUG4 (log_get_system_log_level() >= LOG_DEBUG_DEBUG4)
261 // END ncxlib/log/logmacros
263
264
265
266/* macros to check pthread debug level only ... improves performance when
267 running without debugs enabled */
268#define LOGDEV1_THD (log_get_pthread_log_level() >= LOG_DEBUG_DEV1)
269#define LOGDBG_THD (log_get_pthread_log_level() >= LOG_DEBUG_DEBUG)
270#define LOGDBG2_THD (log_get_pthread_log_level() >= LOG_DEBUG_DEBUG2)
271#define LOGDBG3_THD (log_get_pthread_log_level() >= LOG_DEBUG_DEBUG3)
272#define LOGDBG4_THD (log_get_pthread_log_level() >= LOG_DEBUG_DEBUG4)
273
274 /* Ultra concise version */
275#define DWRT LOG_DEBUG_WRITE
276#define DEV0 LOG_DEBUG_DEV0
277#define DERR LOG_DEBUG_ERROR
278#define DWARN LOG_DEBUG_WARN
279#define DINFO LOG_DEBUG_INFO
280#define DEV1 LOG_DEBUG_DEV1
281#define DBG LOG_DEBUG_DEBUG
282#define DBG1 LOG_DEBUG_DEBUG
283#define DBG2 LOG_DEBUG_DEBUG2
284#define DBG3 LOG_DEBUG_DEBUG3
285#define DBG4 LOG_DEBUG_DEBUG4
286
287#define LOG_DEBUG_STR_OFF (const xmlChar *)"off"
288#define LOG_DEBUG_STR_WRITE (const xmlChar *)"write" /* "Force" output */
289#define LOG_DEBUG_STR_DEV0 (const xmlChar *)"dev0" /* Special debugging */
290#define LOG_DEBUG_STR_ERROR (const xmlChar *)"error"
291#define LOG_DEBUG_STR_WARN (const xmlChar *)"warn"
292#define LOG_DEBUG_STR_INFO (const xmlChar *)"info"
293#define LOG_DEBUG_STR_DEV1 (const xmlChar *)"dev1" /* Special debugging */
294#define LOG_DEBUG_STR_DEBUG (const xmlChar *)"debug"
295#define LOG_DEBUG_STR_DEBUG2 (const xmlChar *)"debug2"
296#define LOG_DEBUG_STR_DEBUG3 (const xmlChar *)"debug3"
297#define LOG_DEBUG_STR_DEBUG4 (const xmlChar *)"debug4"
298
299/* syslog wants to know what app is calling ... */
300#define LOG_DEBUG_APP_STR_UNKNOWN (const char *)"?yuma?"
301#define LOG_DEBUG_APP_STR_YANGCLI (const char *)"yangcli-pro"
302#define LOG_DEBUG_APP_STR_YANGDUMP (const char *)"yangdump-pro"
303#define LOG_DEBUG_APP_STR_YANGDIFF (const char *)"yangdiff-pro"
304#define LOG_DEBUG_APP_STR_NETCONFD (const char *)"netconfd-pro"
305
306/*
307 * Count to skip backtrace frames that are within the logging code ...
308 * these are usually not interesting or meaningful to the end user.
309 */
310#define FRAME_OVERHEAD_CNT 4
311
312/********************************************************************
313* *
314* T Y P E S *
315* *
316*********************************************************************/
317 // BEGIN ncxlib/log/logtypes
326
327
331typedef enum log_stream_t_ {
338
339
343typedef enum log_debug_t_ {
357
358
362typedef enum log_debug_app_t_ {
363 LOG_DEBUG_APP_NONE,
368 LOG_DEBUG_APP_MAX
370
371 // END ncxlib/log/logtypes
373
374
375
376#define VALID_DEBUG_APP(app) \
377 ((app) > LOG_DEBUG_APP_NONE) && ((app) < LOG_DEBUG_APP_MAX)
378
379#define APP_IS_NETCONFD (log_get_debug_app() == LOG_DEBUG_APP_NETCONFD)
380
381/* logging function template to switch between
382 * log_stdout and log_write
383 */
384typedef void (*logfn_void_t) (void);
385
386/*
387 * Function vectors to switch between native versus syslog (or
388 * vendor-specific) logging.
389 */
390typedef void (*logfn_t) (const char *fstr, ...)
391 __attribute__ ((format (printf, 1, 2)));
392
393
394/*
395 * log_common() and log_xxx_common()
396 */
397typedef void (*logfn_cmn_va_t) (boolean recursive,
398 log_debug_t level, log_debug_t sub_level,
399 const char *fstr, va_list args);
400
401/*
402 * log_append() and log_xxx_append()
403 */
404typedef void (*logfn_app_va_t) (boolean recursive,
405 log_debug_t level, log_debug_t sub_level,
406 const char *fstr, va_list args);
407 /* log_flush() and log_xxx_flush() */
408typedef void (*logfn_flush_t) (void);
409 /* log_xxx_connect() */
410typedef void (*logfn_connect_t) (void);
411 /* log_xxx_send() */
412typedef void (*logfn_send_t) (log_debug_app_t app, log_debug_t level,
413 const char *fstr, ...)
414 __attribute__ ((format (printf, 3, 4)));
415
416
417/* Accessed by log_syslog.c and log_vendor.c */
418extern logfn_connect_t logfn_connect;
419extern logfn_send_t logfn_send;
420
421/********************************************************************
422* *
423* V A R I A B L E S *
424* *
425*********************************************************************/
426
427
428
429/********************************************************************
430* *
431* F U N C T I O N S *
432* *
433*********************************************************************/
434
435/*
436* Enforce logger critical section via logger mutex
437*/
438extern void log_enter_cs ( void );
439
440
441/*
442* Enforce logger critical section via logger mutex
443*/
444extern void log_exit_cs ( void );
445
446 // BEGIN ncxlib/log/logfns
460
461
465extern void disable_default_stdout(void);
466
467
471extern void enable_default_stdout(void);
472
473
474
475
481void
482 log_cleanup ( boolean phase2, boolean debugs );
483
484
485/********************************************************************
486* FUNCTION log_internal_err
487*
488* Send internal logging error info to stderr. This function is called
489* when an error is detected while in the process of trying to send
490* info via the logging stream.
491*
492* See also LOG_INTERNAL_ERR() and LOG_INTERNAL_BUF_ERR macros.
493*
494* INPUTS:
495*
496* fstr == format output string
497* ... == variable argument list
498*
499* RETURNS:
500* None
501*********************************************************************/
502void
503 log_internal_err (const char *fstr, ...)
504 __attribute__ ((format (printf, 1, 2)));
505
506void
507 log_internal_lock_err (const char *fstr, ...)
508 __attribute__ ((format (printf, 1, 2)));
509
510
511/********************************************************************
512* FUNCTIONs log_set_xxx and log_get_xxx
513*
514* Read/write support for the various (binary) --log-xxx config
515* options above. Additional comments inline where noteworthy.
516*
517* INPUTS:
518* None
519*
520* RETURNS:
521* if log_get_xxx(), the requested configured value
522*********************************************************************/
523
524/* Backtrace info level */
525extern boolean
526 log_get_backtrace_detail (void);
527extern void
528 log_set_backtrace_detail (void);
529
530/* --logheader="custom" */
531extern void
532 log_set_custom (void);
533
534/* --log-header="localtime" */
535extern void
536 log_set_localtime (void);
537
538/* --log-mirroring */
539extern void
540 log_set_mirroring (void);
541/* --log-mirroring */
542extern boolean
543 log_get_mirroring (void);
544
545/* --log-stderr */
546extern void
547 log_set_stderr (void);
548
549/* --log-suppress-ctrl */
550extern void
551 log_set_suppress_ctrl (void);
552
553/* --log-syslog --log-vendor */
554extern boolean
555 log_get_syslog_bfr_allocated (void);
556
557extern log_debug_t
558 log_syslog_log_level (void);
559
560/* --log-syslog --log-vendor */
561extern boolean
562 log_get_vendor_bfr_allocated (void);
563
564/* --log-syslog --log-vendor */
565extern void
566 log_set_syslog_bfr_allocated (void);
567
568/* --log-syslog --log-vendor */
569extern void
570 log_set_vendor_bfr_allocated (void);
571
572/* --log-syslog --log-vendor */
573extern void
574 log_clr_syslog_bfr_allocated (void);
575
576/* --log-syslog --log-vendor */
577extern void
578 log_clr_vendor_bfr_allocated (void);
579
580/* --log-syslog */
581extern void log_set_syslog (void);
582extern void log_clr_syslog (void);
583extern boolean log_get_syslog (void);
584
585/* --log-vendor */
586extern void
587 log_set_vendor (void);
588
589/* --log-backtrace-stream="logfile" */
590extern void
591 log_set_backtrace_logfile (void);
592
593/* --log-backtrace-stream="stderr" */
594extern void
595 log_set_backtrace_stderr (void);
596
597/* --log-backtrace-stream="stdout" */
598extern void
599 log_set_backtrace_stdout (void);
600
601/* --log-backtrace-stream="syslog" */
602extern boolean
603 log_get_backtrace_syslog (void);
604extern void
605 log_set_backtrace_syslog (void);
606
607/* --log-backtrace-stream="vendor" */
608extern boolean
609 log_get_backtrace_vendor (void);
610extern void
611 log_set_backtrace_vendor (void);
612
613
614/********************************************************************
615 * FUNCTION log_set_backtrace
616*
617* Set the maximum frame count to report on a backtrace log entry
618* (--log-backtrace=<frame_count>)
619*
620* INPUTS:
621*
622* frame_cnt == the requested frame count (if 0 then use internal default).
623*
624* RETURNS:
625* None
626*
627*********************************************************************/
628extern void
629 log_set_backtrace (uint frame_cnt);
630
631
632/********************************************************************
633* FUNCTIONs log_cvt_debug_level2bit
634*
635* Convert a debug level to a unique bit mask
636*
637* INPUTS:
638*
639* level == debug level enum to convert
640*
641* RETURNS:
642* Unique bit mask
643*
644*********************************************************************/
645extern uint
646 log_cvt_debug_level2bit (log_debug_t level);
647
648
649/********************************************************************
650* FUNCTIONs log_set_backtrace_level and log_clear_backtrace_level
651*
652* Manage the debug level bit mask to allow or restrict
653* reporting of backtrace log entries
654*
655* INPUTS:
656*
657* log_set_backtrace_level: level == debug level for which backtrace
658* log entries will be reported
659*
660* log_clear_backtrace_level: level == debug level for which backtrace
661* log entries should no longer be reported
662*
663*
664* RETURNS:
665* none
666*********************************************************************/
667extern void
668 log_clear_backtrace_level (log_debug_t level);
669
670
671extern void
672 log_set_backtrace_level (log_debug_t level);
673
674
675/********************************************************************
676* FUNCTION log_set_backtrace_level_mask
677*
678* Set the debug level bit mask to restrict reporting of backtrace info
679*
680* INPUTS:
681* mask == bit mask respresenting debug levels for which to append
682* backtrace info
683*
684* RETURNS:
685* none
686*********************************************************************/
687extern void
688 log_set_backtrace_level_mask (uint mask);
689
690
691/********************************************************************
692* FUNCTIONs log_get_backtrace_level_mask
693*
694* Return the debug level bit mask in current use
695*
696* INPUTS:
697* none
698*
699* RETURNS:
700* mask == bit mask respresenting debug levels for which to append
701* backtrace info
702*********************************************************************/
703extern uint
704 log_get_backtrace_level_mask (void);
705
706/********************************************************************
707* FUNCTIONs log_test_backtrace_level
708*
709* Return whether a given debug level is enabled for backtrace
710*
711* INPUTS:
712* level == debug level to test
713*
714* RETURNS:
715* TRUE == backtrace enabled for level
716* FALSE == backtrace disabled for level
717*********************************************************************/
718extern boolean
719 log_test_backtrace_level (log_debug_t level);
720
721
722/********************************************************************
723* FUNCTION log_do_backtrace
724*
725* Return the configured status for including backtrace info on a
726* given output stream (e.g., logfile, syslog, stderr, etc.) at a
727* given content level (e.g., error, warn, info, etc.).
728*
729* NOTE: Slightly funky. To use, pass the current (boolean) value
730* of the config flag to be tested, along with the current
731* content level (sub_level).
732*
733* INPUTS:
734*
735* sub_level == the content level for the log output
736* flag == the --log-backtrace-stream flag to test
737*
738* RETURNS:
739*
740* TRUE == backtrace info should be generated
741* FALSE == backtrace info should NOT be generated
742*
743*********************************************************************/
744extern boolean
745 log_do_backtrace (log_debug_t sub_level, boolean flag);
746
747
763extern status_t
764 log_open (const char *fname,
765 boolean append,
766 boolean tstamps);
767
768
774extern void
775 log_close (void);
776
777
793extern status_t
794 log_audit_open (const char *fname,
795 boolean append,
796 boolean tstamps);
797
798
804extern void
805 log_audit_close (void);
806
807
813extern boolean
814 log_audit_is_open (void);
815
816
827extern status_t
828 log_alt_open (const char *fname);
829
830
843extern status_t
844 log_alt_open_ex (const char *fname,
845 boolean overwrite);
846
847
866extern status_t
867 log_alt_open_force (const char *fname,
868 boolean overwrite,
869 boolean force_mode);
870
871
872
878extern void
879 log_alt_close (void);
880
881
889extern void
890 log_init (void);
891
892
893/********************************************************************
894* FUNCTION log_common
895*
896* Generate "new" message log output, optionally pre-pended with an
897* internal status header (date, time, level, etc). Additional info
898* may be appended (via log_append()) on the same or subsequent lines.
899*
900* INPUTS:
901* recursive == TRUE means this is a recursive callback from print_backtrace()
902* level == internal logger "screening" level
903* sub_level == internal logger functional (content) level
904* fstr == format string in printf format
905* args == any additional arguments for printf
906*
907* KLUDGE ALERT:
908* For convenience we equate the 'recursive' param to a call from
909* print_backtrace(), passing this information unvetted on to
910* log_common_internal(). At present, this works because print_backtrace()
911* is the ONLY routine to pass recursive as TRUE. Someday this may change.
912*
913*********************************************************************/
914extern void
915 log_common (boolean recursive, log_debug_t level, log_debug_t sub_level,
916 const char *fstr, va_list args);
917
918
919/*
920* Append formatted string to the current logger output stream
921*
922* INPUTS:
923* recursive == TRUE means this is a recursive callback from print_backtrace()
924* level == internal logger "screening" level
925* sub_level == internal logger functional (content) level
926* fstr == format string in printf format
927* args == additional arguments for printf
928*
929*********************************************************************/
930extern void
931 log_append (boolean recursive, log_debug_t level, log_debug_t sub_level,
932 const char *fstr, va_list args);
933
934
946extern void
947 log_flush (void);
948
949
950/********************************************************************
951* FUNCTION log_print_backtrace
952*
953* Print up to (array[] size) stack frame addresses
954*
955* INPUT:
956*
957* orig_sub_level == content level
958* localfn_flush == flush call vector function
959* max_detail == include maximum backtrace return information
960* frame_overhead == number of frames in logger code (skip)
961* preamble == prompt string to precede backtrace output
962*
963* RETURNS:
964* none
965*********************************************************************/
966extern void
967 log_print_backtrace (boolean syslog_call,
968 log_debug_t orig_sub_level,
969 logfn_flush_t localfn_flush,
970 boolean max_detail,
971 uint frame_overhead,
972 const char *preamble);
973
974
975/********************************************************************
976* FUNCTION log_capture_backtrace
977*
978* Capture backtrace context for storage and later display. Used by
979* chkheaps.c
980*
981* INPUT:
982* strP == ptr to a ptr to an array of printable strings describing the
983* backtrace represented by bt_arrayP. This memory MUST be
984* returned (via free()) by the caller.
985* bt_arrayP == ptr to a (pre-allocated) buffer of size sufficient
986* to hold max_frames backtrace addresses (void * ptrs).
987* max_frames == max frames to dump, preallocated and described by bt_arrayP
988*
989* RETURNS:
990* none
991*********************************************************************/
992extern uint
993 log_capture_backtrace (char ***strP, void *bt_arrayP, uint max_frames);
994
995
996/********************************************************************
997* FUNCTION log_backtrace
998*
999* Output a string followed by backtrace detail, regardless of
1000* backtrace setting.
1001*
1002* In general, use only for debugging ... should not be present in released
1003* software (though it might be useful for debugging in the field).
1004*
1005* INPUTS:
1006* level == output level
1007* fstr == format string for log message
1008* ... == variable arg list for format string
1009*********************************************************************/
1010extern void
1011 log_backtrace (log_debug_t level, const char *fstr, ...)
1012 __attribute__ ((format (printf, 2, 3)));
1013
1014
1015/********************************************************************
1016* FUNCTION log_stderr_backtrace
1017*
1018* Print up to (array[] size) stack frame addresses but output to STDERR.
1019* This is useful for debugging within logger, e.g., when generating an
1020* error internal to the logging subsystem. (See log_internal_err())
1021*
1022* INPUT:
1023*
1024* max_detail == include maximum backtrace return information
1025* preamble == prompt string to precede backtrace output
1026*
1027* RETURNS:
1028* none
1029*********************************************************************/
1030void
1031 log_stderr_backtrace (boolean max_detail, const char *preamble);
1032
1033
1044extern void
1045 log_stdout (const char *fstr, ...)
1046 __attribute__ ((format (printf, 1, 2)));
1047
1048
1056extern void
1057 log_stdout_level (log_debug_t level, const char *fstr, ...)
1058 __attribute__ ((format (printf, 2, 3)));
1059
1060
1071extern void
1072 log_write (const char *fstr, ...)
1073 __attribute__ ((format (printf, 1, 2)));
1074
1082extern void
1083 log_write_append (const char *fstr, ...)
1084 __attribute__ ((format (printf, 1, 2)));
1085
1086
1087extern void
1088 log_write_filtered (log_debug_t level, const char *fstr, ...)
1089 __attribute__ ((format (printf, 2, 3)));
1090
1091extern void
1092 log_write_filtered_append (log_debug_t level, const char *fstr, ...)
1093 __attribute__ ((format (printf, 2, 3)));
1094
1095extern void
1096 log_write_syslog_level (log_debug_t level, const char *fstr, ...)
1097 __attribute__ ((format (printf, 2, 3)));
1098
1099extern void
1100 log_write_syslog_level_append (log_debug_t level, const char *fstr, ...)
1101 __attribute__ ((format (printf, 2, 3)));
1102
1103
1112extern void
1113 log_audit_write (const char *fstr, ...)
1114 __attribute__ ((format (printf, 1, 2)));
1115
1116
1125extern void
1126 log_audit_write_level (log_debug_t level, const char *fstr, ...)
1127 __attribute__ ((format (printf, 2, 3)));
1128
1129
1130/********************************************************************
1131* FUNCTION log_audit_indent
1132*
1133* Printf a newline to the audit logfile,
1134* then the specified number of space chars
1135*
1136* INPUTS:
1137* indentcnt == number of indent chars, -1 == skip everything
1138*
1139*********************************************************************/
1140extern void
1141 log_audit_indent (int32 indentcnt);
1142
1143extern void
1144 log_audit_indent_level (log_debug_t level, int32 indentcnt);
1145
1146
1153extern void
1154 log_alt_write (const char *fstr, ...)
1155 __attribute__ ((format (printf, 1, 2)));
1156
1157
1165extern void
1166 log_alt_write_level (log_debug_t level, const char *fstr, ...)
1167 __attribute__ ((format (printf, 2, 3)));
1168
1169
1170
1171/********************************************************************
1172* FUNCTION log_alt_indent
1173*
1174* Printf a newline to the alternate logfile,
1175* then the specified number of space chars
1176*
1177* INPUTS:
1178* indentcnt == number of indent chars, -1 == skip everything
1179*
1180*********************************************************************/
1181extern void
1182 log_alt_indent (int32 indentcnt);
1183
1184extern void
1185 log_alt_indent_level (log_debug_t level, int32 indentcnt);
1186
1187
1188/********************************************************************
1189* FUNCTION vlog_error
1190*
1191* Generate a LOG_DEBUG_ERROR log entry
1192*
1193* INPUTS:
1194* fstr == format string in printf format
1195* valist == any additional arguments for printf
1196*
1197*********************************************************************/
1198void
1199 vlog_error (const char *fstr, va_list args );
1200
1201
1214extern void
1215 log_error (const char *fstr, ...)
1216 __attribute__ ((format (printf, 1, 2)));
1217
1218
1226extern void
1227 log_error_append (const char *fstr, ...)
1228 __attribute__ ((format (printf, 1, 2)));
1229
1230
1238extern void
1239 log_warn (const char *fstr, ...)
1240 __attribute__ ((format (printf, 1, 2)));
1241
1242
1250extern void
1251 log_warn_append (const char *fstr, ...)
1252 __attribute__ ((format (printf, 1, 2)));
1253
1254
1262extern void
1263 log_info (const char *fstr, ...)
1264 __attribute__ ((format (printf, 1, 2)));
1265
1266
1274extern void
1275 log_info_append (const char *fstr, ...)
1276 __attribute__ ((format (printf, 1, 2)));
1277
1278
1286extern void
1287 log_debug (const char *fstr, ...)
1288 __attribute__ ((format (printf, 1, 2)));
1289
1290
1298extern void
1299 log_debug_append (const char *fstr, ...)
1300 __attribute__ ((format (printf, 1, 2)));
1301
1302
1310extern void
1311 log_debug2 (const char *fstr, ...)
1312 __attribute__ ((format (printf, 1, 2)));
1313
1314
1322extern void
1323 log_debug2_append (const char *fstr, ...)
1324 __attribute__ ((format (printf, 1, 2)));
1325
1326
1334extern void
1335 log_debug3 (const char *fstr, ...)
1336 __attribute__ ((format (printf, 1, 2)));
1337
1338
1346extern void
1347 log_debug3_append (const char *fstr, ...)
1348 __attribute__ ((format (printf, 1, 2)));
1349
1350
1358extern void
1359 log_debug4 (const char *fstr, ...)
1360 __attribute__ ((format (printf, 1, 2)));
1361
1362
1370extern void
1371 log_debug4_append (const char *fstr, ...)
1372 __attribute__ ((format (printf, 1, 2)));
1373
1374
1375/********************************************************************
1376* FUNCTIONs log_dev0 and log_dev0_append
1377*
1378* Generate (append to) a LOG_DEBUG_DEV0 log entry
1379*
1380* NOTE: This level is intended primarily for debugging, where output related
1381* issues at {ERROR, WARN, INFO} levels change program behavior)
1382*
1383* INPUTS:
1384* fstr == format string in printf format
1385* ... == any additional arguments for printf
1386*
1387*********************************************************************/
1388extern void
1389 log_dev0 (const char *fstr, ...)
1390 __attribute__ ((format (printf, 1, 2)));
1391
1392extern void
1393 log_dev0_append (const char *fstr, ...)
1394 __attribute__ ((format (printf, 1, 2)));
1395
1396
1397/********************************************************************
1398* FUNCTIONs log_dev1 and log_dev1_append
1399*
1400* Generate (append to) a LOG_DEBUG_DEV1 log entry
1401*
1402* NOTE: This level is intended primarily for debugging, where output related
1403* issues at {DEBUG, DEBUG2, DEBUG3, DEBUG4} change program behavior)
1404*
1405* INPUTS:
1406* fstr == format string in printf format
1407* ... == any additional arguments for printf
1408*
1409*********************************************************************/
1410extern void
1411 log_dev1 (const char *fstr, ...)
1412 __attribute__ ((format (printf, 1, 2)));
1413
1414extern void
1415 log_dev1_append (const char *fstr, ...)
1416 __attribute__ ((format (printf, 1, 2)));
1417
1418
1419/********************************************************************
1420* FUNCTIONs log_write_level and log_write_level_append
1421*
1422* Generate (append to) a LOG_DEBUG_<LEVEL> log trace entry
1423*
1424* NOTE: Useful when the desired debug level is passed as a param
1425*
1426* INPUTS:
1427* level == debug level
1428* fstr == format string in printf format
1429* ... == any additional arguments for printf
1430*
1431*********************************************************************/
1432extern void
1433 log_write_level (log_debug_t level, const char *fstr, ...)
1434 __attribute__ ((format (printf, 2, 3)));
1435
1436extern void
1437 log_write_level_append (log_debug_t level, const char *fstr, ...)
1438 __attribute__ ((format (printf, 2, 3)));
1439
1440
1441
1448extern logfn_t
1449 log_get_logfn (log_debug_t loglevel);
1450
1451
1459extern logfn_t
1460 log_get_appendfn (log_debug_t loglevel);
1461
1462
1463
1464/********************************************************************
1465* FUNCTIONs log_xxx_thd and log_xxx_append_thd
1466*
1467* Generate (or append to) a "thread" LOG_DEBUG_XXX level log entry
1468*
1469* INPUTS:
1470* fstr == format string in printf format
1471* ... == any additional arguments for printf
1472*
1473*********************************************************************/
1474#ifdef PTHREADS
1475extern void
1476 log_dev1_thd (const char *fstr, ...)
1477 __attribute__ ((format (printf, 1, 2)));
1478
1479extern void
1480 log_dev1_append_thd (const char *fstr, ...)
1481 __attribute__ ((format (printf, 1, 2)));
1482
1483extern void
1484 log_debug_thd (const char *fstr, ...)
1485 __attribute__ ((format (printf, 1, 2)));
1486
1487extern void
1488 log_debug_append_thd (const char *fstr, ...)
1489 __attribute__ ((format (printf, 1, 2)));
1490
1491extern void
1492 log_debug2_thd (const char *fstr, ...)
1493 __attribute__ ((format (printf, 1, 2)));
1494
1495extern void
1496 log_debug2_append_thd (const char *fstr, ...)
1497 __attribute__ ((format (printf, 1, 2)));
1498
1499extern void
1500 log_debug3_thd (const char *fstr, ...)
1501 __attribute__ ((format (printf, 1, 2)));
1502
1503extern void
1504 log_debug3_append_thd (const char *fstr, ...)
1505 __attribute__ ((format (printf, 1, 2)));
1506
1507extern void
1508 log_debug4_thd (const char *fstr, ...)
1509 __attribute__ ((format (printf, 1, 2)));
1510
1511extern void
1512 log_debug4_append_thd (const char *fstr, ...)
1513 __attribute__ ((format (printf, 1, 2)));
1514#endif //#ifdef PTHREADS
1515
1516
1517/********************************************************************
1518* FUNCTION log_noop
1519*
1520* Do not generate any log message NO-OP
1521* Used to set logfn_t to no-loggging option
1522*
1523* INPUTS:
1524* fstr == format string in printf format
1525* ... == any additional arguments for printf
1526*
1527*********************************************************************/
1528extern void
1529 log_noop (const char *fstr, ...)
1530 __attribute__ ((format (printf, 1, 2)));
1531
1532
1538extern void log_set_log_level (log_debug_t dlevel);
1539
1545extern void log_set_syslog_log_level (log_debug_t dlevel);
1546
1547
1548#ifdef PTHREADS
1554extern void log_set_pthread_log_level (log_debug_t dlevel);
1555#endif // PTHREADS
1556
1557
1558/*
1559* FUNCTION log_get_system_log_level
1560*
1561* Get the global debug filter threshold level
1562*
1563* RETURNS:
1564* the debug level
1565*********************************************************************/
1566extern log_debug_t log_get_system_log_level (void);
1567
1568
1574extern log_debug_t log_get_log_level (void);
1575
1576
1583
1584
1591
1592
1593/********************************************************************
1594* FUNCTION log_get_debug_level_enum
1595*
1596* Get the corresponding debug enum for the specified string
1597*
1598* INPUTS:
1599* str == string value to convert
1600*
1601* RETURNS:
1602* the corresponding enum for the specified debug level
1603*********************************************************************/
1604extern log_debug_t
1605 log_get_debug_level_enum (const char *str);
1606
1607extern uint
1608 log_parse_debug_level_str (const char *str);
1609
1610
1611/********************************************************************
1612* FUNCTION log_get_debug_level_string
1613*
1614* Get the corresponding string for the debug enum
1615*
1616* INPUTS:
1617* level == the enum for the specified debug level
1618*
1619* RETURNS:
1620* the string value for this enum
1621
1622*********************************************************************/
1623extern const xmlChar *
1624 log_get_debug_level_string (log_debug_t level);
1625
1626
1627
1628/********************************************************************
1629* FUNCTION log_get_debug_level_value
1630*
1631* Get the corresponding YANG enum value for the debug enum
1632*
1633* INPUTS:
1634* level == the enum for the specified debug level
1635*
1636* RETURNS:
1637* the int32 value for this enum
1638*********************************************************************/
1639extern int32
1640 log_get_debug_level_value (log_debug_t level);
1641
1642
1643/********************************************************************
1644* FUNCTION log_get_debug_app_string
1645*
1646* Get the corresponding string for the debug app enum
1647*
1648* INPUTS:
1649* app == the enum for the specified debug app
1650*
1651* RETURNS:
1652* the string value for this enum
1653
1654*********************************************************************/
1655extern const char *
1656 log_debug_get_app_string (log_debug_app_t app);
1657
1658/********************************************************************
1659* FUNCTION log_debug_app2facility
1660*
1661* Translate from YumaPro app to syslog facility
1662*
1663* INPUTS:
1664* app == the enum for the specified YUMA app
1665*
1666* RETURNS:
1667* Appropriate syslog facility code
1668*
1669*********************************************************************/
1670extern int
1671 log_debug_app2facility (log_debug_app_t app);
1672
1673
1674/********************************************************************
1675* FUNCTION log_set_debug_app
1676*
1677* Set syslog application level ... for example, yangcli will set
1678* USER while netconfd will set DAEMON for use by syslog.
1679*
1680* INPUTS:
1681* app == the enum for the specified YUMA app
1682*
1683* RETURNS:
1684* None
1685*
1686*********************************************************************/
1687extern void
1688 log_set_debug_app (log_debug_app_t app);
1689
1690
1691/********************************************************************
1692* FUNCTION log_get_debug_app
1693*
1694* Return syslog application level.
1695*
1696* INPUTS:
1697* None
1698*
1699* RETURNS:
1700* enum for the current YUMA app
1701*
1702*********************************************************************/
1703extern log_debug_app_t
1704 log_get_debug_app (void);
1705
1706
1707/********************************************************************
1708* FUNCTION log_debug_app_string
1709*
1710* Return syslog application level string equivalent
1711*
1712* INPUTS:
1713* None
1714*
1715* RETURNS:
1716* String equivalent for the current YUMA app type
1717*
1718*********************************************************************/
1719extern const char *
1720 log_debug_app_string (void);
1721
1722/********************************************************************
1723* FUNCTION log_is_open
1724*
1725* Check if the logfile is active
1726*
1727* RETURNS:
1728* TRUE if logfile open, FALSE otherwise
1729*********************************************************************/
1730extern boolean
1731 log_is_open (void);
1732
1733
1734/********************************************************************
1735* FUNCTION log_indent
1736*
1737* Printf a newline, then the specified number of chars
1738*
1739* INPUTS:
1740* indentcnt == number of indent chars, -1 == skip everything
1741*
1742*********************************************************************/
1743extern void
1744 log_indent (int32 indentcnt);
1745extern void
1746 log_indent_append (int32 indentcnt);
1747extern void
1748 log_indent_level_append (log_debug_t level, int32 indentcnt);
1749
1750
1751/********************************************************************
1752* FUNCTION log_stdout_indent
1753*
1754* Printf a newline to stdout, then the specified number of chars
1755*
1756* INPUTS:
1757* indentcnt == number of indent chars, -1 == skip everything
1758*
1759*********************************************************************/
1760extern void
1761 log_stdout_indent (int32 indentcnt);
1762
1763extern void
1764 log_stdout_level_indent (log_debug_t level, int32 indentcnt);
1765
1766
1767/********************************************************************
1768* FUNCTION log_get_logfile
1769*
1770* Get the open logfile for direct output
1771* Needed by libtecla to write command line history
1772*
1773* RETURNS:
1774* pointer to open FILE if any
1775* NULL if no open logfile
1776*********************************************************************/
1777extern FILE *
1778 log_get_logfile (void);
1779
1780
1781/********************************************************************
1782* FUNCTION log_start_capture
1783*
1784* Open a capture logfile for writing
1785*
1786* INPUTS:
1787* fname == full filespec string for capfile
1788*
1789* RETURNS:
1790* status
1791*********************************************************************/
1792extern status_t
1793 log_start_capture (const char *fname);
1794
1795
1796/********************************************************************
1797* FUNCTION log_end_capture
1798*
1799* Close a capture logfile after writing
1800*
1801*********************************************************************/
1802extern void
1803 log_end_capture (void);
1804
1805
1806/********************************************************************
1807* FUNCTION log_trigger_rotate
1808*
1809* Trigger the logrotate procedure
1810*
1811* RETURNS:
1812* none
1813*********************************************************************/
1814extern void
1815 log_trigger_rotate (void);
1816
1817/********************************************************************
1818* FUNCTION log_rotate_requested
1819*
1820* Check if logrotate procedure is in progress
1821*
1822* RETURNS:
1823* TRUE if logrotate procedure has been started
1824*
1825*********************************************************************/
1826extern boolean
1827 log_rotate_requested (void);
1828
1829
1841extern void
1842 log_set_highres_datetime (boolean val);
1843
1844
1851extern boolean
1853
1854
1855 // END ncxlib/log/logfns
1857
1858
1859
1860#ifdef __cplusplus
1861} /* end extern 'C' */
1862#endif
1863
1864#endif /* _H_log */
void log_alt_write(const char *fstr,...) __attribute__((format(printf
Write to the alternate log file.
logfn_t log_get_appendfn(log_debug_t loglevel)
Get the logfn_t for the corresponding log-level FOR APPEND.
Definition: log.c:3254
void void log_alt_write_level(log_debug_t level, const char *fstr,...) __attribute__((format(printf
Write to the alternate log file if debug-level set.
void log_error(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_ERROR log entry.
void void log_error_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_ERROR log entry.
void log_init(void)
Initialize logger state.
Definition: log.c:534
void log_close(void)
Close the logfile.
Definition: log.c:1125
log_debug_t log_get_pthread_log_level(void)
Get the pthreads log level.
Definition: log.c:3739
void void void void void void void log_debug(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_DEBUG log entry.
void void log_stdout_level(log_debug_t level, const char *fstr,...) __attribute__((format(printf
Write output to STDOUT if debug level set.
void log_flush(void)
Flush output buffers.
Definition: log.c:1979
status_t log_alt_open_force(const char *fname, boolean overwrite, boolean force_mode)
Open an alternate logfile for writing.
Definition: log.c:1280
void void void void void void void void void void void void log_set_log_level(log_debug_t dlevel)
Set the main log level.
Definition: log.c:3574
void void void log_write(const char *fstr,...) __attribute__((format(printf
Write a new entry to the main log.
void void void void void void void void void void void log_debug3(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_DEBUG3 log entry.
log_debug_t log_get_log_level(void)
Get the main log level.
Definition: log.c:3687
void void void void void void void void void log_audit_write(const char *fstr,...) __attribute__((format(printf
Write an new entry to the audit log file.
void log_set_highres_datetime(boolean val)
Set the high resolution date-time usage flag.
Definition: log.c:4307
log_debug_t log_get_syslog_log_level(void)
Get the syslog log level.
Definition: log.c:3702
void void void void void void void void void void log_audit_write_level(log_debug_t level, const char *fstr,...) __attribute__((format(printf
Write an new entry to the audit log file if the log level is set.
void void void void void void void void void void void void log_debug3_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_DEBUG3 log entry.
void disable_default_stdout(void)
Used by yp-client to disable log.c output.
Definition: log.c:265
void void void void void void void void void void void void void void void void void void void void logfn_t log_get_logfn(log_debug_t loglevel)
Get the logfn_t for the corresponding log-level.
Definition: log.c:3214
status_t log_alt_open(const char *fname)
Open an alternate logfile for writing.
Definition: log.c:1230
void log_alt_close(void)
Close the alternate logfile.
Definition: log.c:1317
boolean log_audit_is_open(void)
Check if the audit log is open.
Definition: log.c:1209
void void void void void void void void void void void void void void log_debug4_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_DEBUG4 log entry.
void void void log_warn(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_WARN log entry.
void void void void void void void void void void log_debug2_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_DEBUG2 log entry.
void void void void log_warn_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_WARN log entry.
boolean log_get_highres_datetime(void)
Get the high resolution date-time usage flag.
Definition: log.c:4325
status_t log_open(const char *fname, boolean append, boolean tstamps)
Open a logfile for writing.
Definition: log.c:1107
void log_audit_close(void)
Close the audit_logfile.
Definition: log.c:1181
void log_set_pthread_log_level(log_debug_t dlevel)
Set the pthreads log level.
Definition: log.c:3649
void log_set_syslog_log_level(log_debug_t dlevel)
Set the syslog log level.
Definition: log.c:3617
void void void void void void void void log_debug_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_DEBUG log entry.
void log_stdout(const char *fstr,...) __attribute__((format(printf
Write output to STDOUT.
status_t log_audit_open(const char *fname, boolean append, boolean tstamps)
Open the audit logfile for writing.
Definition: log.c:1163
void void void void void void void void void void void void void log_debug4(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_DEBUG4 log entry.
void void void void void void log_info_append(const char *fstr,...) __attribute__((format(printf
Append to a LOG_DEBUG_INFO log entry.
void void void void log_write_append(const char *fstr,...) __attribute__((format(printf
Append to the last log entry to the main log.
void void void void void log_info(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_INFO log entry.
void enable_default_stdout(void)
Used by C program variants of yp-client to enable log.c output.
Definition: log.c:270
status_t log_alt_open_ex(const char *fname, boolean overwrite)
Open an alternate logfile for writing.
Definition: log.c:1251
void log_cleanup(boolean phase2, boolean debugs)
Final logger cleanup prior to restart or shutdown.
Definition: log.c:559
void void void void void void void void void log_debug2(const char *fstr,...) __attribute__((format(printf
Generate a new LOG_DEBUG_DEBUG2 log entry.
log_debug_app_t
syslog wants to know what app is logging ...
Definition: log.h:362
log_stream_t
The output stream enumerations used in util/log.c.
Definition: log.h:331
log_debug_t
The debug level enumerations used in util/log.c.
Definition: log.h:343
@ LOG_DEBUG_APP_YANGDIFF
app is yangdiff
Definition: log.h:366
@ LOG_DEBUG_APP_YANGCLI
app is yangcli
Definition: log.h:364
@ LOG_DEBUG_APP_NETCONFD
app is netconfd
Definition: log.h:367
@ LOG_DEBUG_APP_YANGDUMP
app is yangdump
Definition: log.h:365
@ LOG_STREAM_LOGFILE
Output destined for logfile.
Definition: log.h:335
@ LOG_STREAM_STDERR
Output destined for stderr.
Definition: log.h:334
@ LOG_STREAM_NONE
value not set or error
Definition: log.h:332
@ LOG_STREAM_STDOUT
Output destined for stdout.
Definition: log.h:333
@ LOG_STREAM_CAPFILE
Output destined for capfile.
Definition: log.h:336
@ LOG_DEBUG_DEV0
Special use developer debugging only.
Definition: log.h:347
@ LOG_DEBUG_NONE
value not set or error
Definition: log.h:344
@ LOG_DEBUG_ERROR
fatal + internal errors only
Definition: log.h:348
@ LOG_DEBUG_DEBUG
debug level 1
Definition: log.h:352
@ LOG_DEBUG_WARN
all errors + warnings
Definition: log.h:349
@ LOG_DEBUG_DEBUG2
debug level 2
Definition: log.h:353
@ LOG_DEBUG_INFO
all previous + user info trace
Definition: log.h:350
@ LOG_DEBUG_DEBUG4
debug level 4
Definition: log.h:355
@ LOG_DEBUG_DEV1
Special use developer debugging only.
Definition: log.h:351
@ LOG_DEBUG_WRITE
logging turned on
Definition: log.h:346
@ LOG_DEBUG_DEBUG3
debug level 3
Definition: log.h:354
@ LOG_DEBUG_OFF
logging turned off
Definition: log.h:345
status_t
global error return code
Definition: status_enum.h:210
Global error messages for status code enumerations.
Thread support (for now limited to netconfd)