← Back to branch summary

~noskcaj/ubuntu/saucy/xinetd/2.3.15

« back to all changes in this revision

Viewing changes to xinetd/logctl.c

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Seyrat
  • Date: 2004-04-18 13:33:57 UTC
  • Revision ID: james.westby@ubuntu.com-20040418133357-czeqeju37433xvdd
Tags: upstream-2.3.13
Import upstream version 2.3.13

Show diffs side-by-side

added added

removed removed

Lines of Context:
xinetd/logctl.c
 
1
/*
 
2
 * (c) Copyright 1992 by Panagiotis Tsirigotis
 
3
 * (c) Copyright 1998-2001 by Rob Braun
 
4
 * All rights reserved.  The file named COPYRIGHT specifies the terms 
 
5
 * and conditions for redistribution.
 
6
 */
 
7
 
 
8
 
 
9
#include "config.h"
 
10
#include <sys/types.h>
 
11
#include <sys/stat.h>
 
12
#include <syslog.h>
 
13
#include <fcntl.h>
 
14
 
 
15
#include "logctl.h"
 
16
#include "msg.h"
 
17
#include "xconfig.h"
 
18
#include "main.h"
 
19
#include "sconf.h"
 
20
 
 
21
 
 
22
static xlog_h start_filelog( const char *id, struct filelog *flp )
 
23
{
 
24
   xlog_h   xh ;
 
25
   int      fd ;
 
26
   int      log_file_mode = ( debug.on ) ? 0644 : LOG_FILE_MODE ;
 
27
   const char *func = "start_filelog" ;
 
28
 
 
29
   xh = xlog_create( XLOG_FILELOG, id, XLOG_NOFLAGS,
 
30
                     flp->fl_filename, LOG_OPEN_FLAGS, log_file_mode ) ;
 
31
   if ( xh == NULL )
 
32
   {
 
33
      msg( LOG_ERR, func, "creation of %s log failed", id ) ;
 
34
      return( NULL ) ;
 
35
   }
 
36
 
 
37
   if ( xlog_control( xh, XLOG_GETFD, &fd ) != XLOG_ENOERROR ||
 
38
        fcntl( fd,  F_SETFD, FD_CLOEXEC ) == -1 )
 
39
   {
 
40
      msg( LOG_ERR, func, "Failed to set close-on-exec flag for log file" ) ;
 
41
      xlog_destroy( xh ) ;
 
42
      return( NULL ) ;
 
43
   }
 
44
 
 
45
   ps.rws.descriptors_free-- ;
 
46
 
 
47
   if ( FILELOG_SIZE_CONTROL( flp ) )
 
48
      (void) xlog_control( xh,
 
49
                     XLOG_LIMITS, flp->fl_soft_limit, flp->fl_hard_limit ) ;
 
50
 
 
51
   return( xh ) ;
 
52
}
 
53
 
 
54
 
 
55
/*
 
56
 * This function is invoked when a xlog detects an error (for example,
 
57
 * exceeding the file size limit).
 
58
 * The function just enters a log message.
 
59
 * 
 
60
 * NOTE: We could destroy the xlog at this point but we choose not to.
 
61
 */
 
62
static void log_in_error( xlog_h xh, int error_code, void *arg )
 
63
{
 
64
   struct service     *sp       = SP( arg ) ;
 
65
   const char         *log_id   = ( sp == NULL ) ? "common" : SVC_ID( sp ) ;
 
66
   const char         *func     = "log_in_error" ;
 
67
 
 
68
#ifdef lint
 
69
   xh = xh ;
 
70
#endif
 
71
   if ( error_code == XLOG_ESIZE )
 
72
      msg( LOG_ERR, func, "Size of %s log exceeded hard limit", log_id ) ;
 
73
   else
 
74
      msg( LOG_ERR, func, "Error in %s log: %d", log_id, error_code ) ;
 
75
}
 
76
 
 
77
/*
 
78
 * Start logging for the specified service.
 
79
 * The current configuration is used to determine the common log file.
 
80
 */
 
81
status_e log_start( struct service *sp, xlog_h *xhp )
 
82
{
 
83
   xlog_h        xh ;
 
84
   const char   *sid   = SVC_ID( sp ) ;
 
85
   struct log   *lp    = SC_LOG( SVC_CONF( sp ) ) ;
 
86
   const char   *func  = "log_start" ;
 
87
 
 
88
   switch ( lp->l_type )
 
89
   {
 
90
      case L_NONE:
 
91
         xh = NULL ;
 
92
         break ;
 
93
 
 
94
      case L_SYSLOG:
 
95
         xh = xlog_create( XLOG_SYSLOG, sid, XLOG_NOFLAGS, 
 
96
                  LOG_GET_SYSLOG( lp )->sl_facility,
 
97
                  LOG_GET_SYSLOG( lp )->sl_level ) ;
 
98
         if ( xh == NULL )
 
99
         {
 
100
            msg( LOG_ERR, func, "failed to create a log for service %s", sid ) ;
 
101
            return( FAILED ) ;
 
102
         }
 
103
         xlog_control( xh, XLOG_CALLBACK, log_in_error, (void *)sp ) ;
 
104
         break ;
 
105
      
 
106
      case L_FILE:
 
107
         /*
 
108
          * NOTE: if the same file is specified for more than one service,
 
109
          *         it will be opened as many times.
 
110
          *         Furthermore, size control will not be accurate.
 
111
          */
 
112
         xh = start_filelog( sid, LOG_GET_FILELOG( lp ) ) ;
 
113
         if ( xh == NULL )
 
114
            return( FAILED ) ;
 
115
         (void) xlog_control( xh, XLOG_CALLBACK, log_in_error, (void *)sp ) ;
 
116
         break ;
 
117
      
 
118
      case L_COMMON_FILE:
 
119
         if ( DEFAULT_LOG( ps ) == NULL )
 
120
            if ( DEFAULT_LOG_ERROR( ps ) )
 
121
               return( FAILED ) ;
 
122
            else
 
123
            {
 
124
               xh = start_filelog( "default", 
 
125
                              LOG_GET_FILELOG( SC_LOG( DEFAULTS( ps ) ) ) ) ;
 
126
               if ( xh == NULL )
 
127
               {
 
128
                  DEFAULT_LOG_ERROR( ps ) = TRUE ;
 
129
                  return( FAILED ) ;
 
130
               }
 
131
               DEFAULT_LOG( ps ) = xh ;
 
132
               (void) xlog_control( xh,
 
133
                           XLOG_CALLBACK, log_in_error, VOID_NULL ) ;
 
134
            }
 
135
         else
 
136
            xh = DEFAULT_LOG( ps ) ;
 
137
         break ;
 
138
 
 
139
      default:         /* SHOULDN'T HAPPEN */
 
140
         msg( LOG_ERR, func, "bad log type (%d) for service %s",
 
141
            (int) LOG_GET_TYPE( lp ), sid ) ;
 
142
         return( FAILED ) ;
 
143
   }
 
144
   *xhp = xh ;
 
145
   return( OK ) ;
 
146
}
 
147
 
 
148
 
 
149
void log_end( struct log *lp, xlog_h xh )
 
150
{
 
151
   const char *func = "log_end" ;
 
152
 
 
153
   if ( xh == NULL )      /* shouldn't be NULL but just in case */
 
154
   {
 
155
      msg( LOG_NOTICE, func, "called with NULL handle" ) ;
 
156
      return ;
 
157
   }
 
158
 
 
159
   switch ( LOG_GET_TYPE( lp ) )
 
160
   {
 
161
      case L_FILE:
 
162
         ps.rws.descriptors_free++ ;
 
163
         /* FALL THROUGH */
 
164
      
 
165
      case L_SYSLOG:
 
166
         xlog_destroy( xh ) ;
 
167
      case L_NONE:
 
168
      case L_COMMON_FILE:
 
169
         ;
 
170
   }
 
171
}
 
172