← Back to branch summary

~ubuntu-branches/ubuntu/trusty/syslog-ng/trusty-proposed

« back to all changes in this revision

Viewing changes to src/afstreams.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-03-14 12:57:49 UTC
  • mfrom: (1.3.1 upstream) (12.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20100314125749-m3ats648sp2urg0f
Tags: 3.0.5-1
New upstream release, new maintainer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/afstreams.c
1
1
/*
2
 
 * Copyright (c) 2002-2007 BalaBit IT Ltd, Budapest, Hungary                    
 
2
 * Copyright (c) 2002-2009 BalaBit IT Ltd, Budapest, Hungary
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify it
5
5
 * under the terms of the GNU General Public License version 2 as published
20
20
 * along with this program; if not, write to the Free Software
21
21
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22
22
 */
23
 
 
 
23
  
24
24
#include "afstreams.h"
25
25
#include "messages.h"
26
26
#include "logreader.h"
27
27
#include "misc.h"
 
28
#include "apphook.h"
 
29
#include "stats.h"
28
30
 
29
31
typedef struct _AFStreamsSourceDriver
30
32
{
51
53
#endif
52
54
 
53
55
 
54
 
static size_t
55
 
streams_read_read_method(FDRead *self, void *buf, size_t buflen, GSockAddr **sa)
 
56
static gssize
 
57
log_transport_streams_read(LogTransport *self, void *buf, gsize buflen, GSockAddr **sa)
56
58
{
57
59
  struct strbuf ctl, data;
58
60
  struct log_ctl lc;
69
71
  flags = 0;
70
72
 
71
73
  res = getmsg(self->fd, &ctl, &data, &flags);
72
 
  if ((res & (MORECTL+MOREDATA)) == 0)
 
74
  if (res == -1)
 
75
    return -1;
 
76
  else if ((res & (MORECTL+MOREDATA)) == 0)
73
77
    {
74
78
      len = g_snprintf(buf, buflen, "<%d>%.*s", lc.pri, data.len, data.buf);
75
79
      return MIN(len, buflen);
83
87
  return 0;
84
88
}
85
89
 
86
 
FDRead *
87
 
streams_read_new(gint fd)
 
90
LogTransport *
 
91
log_transport_streams_new(gint fd)
88
92
{
89
 
  FDRead *self = g_new0(FDRead, 1);
 
93
  LogTransport *self = g_new0(LogTransport, 1);
90
94
  
91
95
  self->fd = fd;
92
96
  self->cond = G_IO_IN;
93
 
  self->read = streams_read_read_method;
 
97
  self->read = log_transport_streams_read;
 
98
  self->free_fn = log_transport_free_method;
94
99
  return self;
95
100
}
96
101
 
103
108
}
104
109
 
105
110
static void 
106
 
afstreams_sd_door_server_proc(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, size_t n_desc)
 
111
afstreams_sd_door_server_proc(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, uint_t n_desc)
107
112
{
108
113
  door_return(NULL, 0, NULL, 0);
109
114
  return;
110
115
}
111
116
 
 
117
static void
 
118
afstreams_init_door(int hook_type G_GNUC_UNUSED, gpointer user_data)
 
119
{
 
120
  AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) user_data;
 
121
  struct stat st;
 
122
  gint fd;
 
123
  
 
124
  if (stat(self->door_filename->str, &st) == -1)
 
125
    {
 
126
      /* file does not exist, create it */
 
127
      fd = creat(self->door_filename->str, 0666);
 
128
      if (fd == -1)
 
129
        {
 
130
          msg_error("Error creating syslog door file",
 
131
                    evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
 
132
                    evt_tag_errno(EVT_TAG_OSERROR, errno),
 
133
                    NULL);
 
134
          close(fd);
 
135
          return;
 
136
        }
 
137
    }
 
138
  fdetach(self->door_filename->str);
 
139
  self->door_fd = door_create(afstreams_sd_door_server_proc, NULL, 0);
 
140
  if (self->door_fd == -1)
 
141
    {
 
142
      msg_error("Error creating syslog door",
 
143
                evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
 
144
                evt_tag_errno(EVT_TAG_OSERROR, errno),
 
145
                NULL);
 
146
      return;
 
147
    }
 
148
  g_fd_set_cloexec(self->door_fd, TRUE);
 
149
  if (fattach(self->door_fd, self->door_filename->str) == -1)
 
150
    {
 
151
      msg_error("Error attaching syslog door",
 
152
                evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
 
153
                evt_tag_errno(EVT_TAG_OSERROR, errno),
 
154
                NULL);
 
155
      close(self->door_fd);
 
156
      self->door_fd = -1;
 
157
      return;
 
158
    }
 
159
}
 
160
 
112
161
static gboolean
113
 
afstreams_sd_init(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
 
162
afstreams_sd_init(LogPipe *s)
114
163
{
115
164
  AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
 
165
  GlobalConfig *cfg = log_pipe_get_config(s);
116
166
  gint fd;
117
167
  
118
 
  log_reader_options_init(&self->reader_options, cfg);
 
168
  log_reader_options_init(&self->reader_options, cfg, self->super.group);
119
169
  
120
170
  fd = open(self->dev_filename->str, O_RDONLY | O_NOCTTY | O_NONBLOCK);
121
171
  if (fd != -1)
134
184
          close(fd);
135
185
          return FALSE;
136
186
        }
137
 
      self->reader = log_reader_new(streams_read_new(fd), LR_LOCAL | LR_NOMREAD | LR_PKTTERM, s, &self->reader_options);
 
187
      g_fd_set_nonblock(fd, TRUE);
 
188
      self->reader = log_reader_new(log_proto_plain_new_server(log_transport_streams_new(fd), 0, self->reader_options.msg_size, LPPF_PKTTERM), LR_LOCAL);
 
189
      log_reader_set_options(self->reader, s, &self->reader_options, 1, SCS_SUN_STREAMS, self->super.id, self->dev_filename->str);
138
190
      log_pipe_append(self->reader, s);
139
191
      
140
192
      if (self->door_filename)
141
193
        {
142
 
          struct stat st;
143
 
          
144
 
          if (stat(self->door_filename->str, &st) == -1)
145
 
            {
146
 
              /* file does not exist, create it */
147
 
              fd = creat(self->door_filename->str, 0666);
148
 
              if (fd == -1)
149
 
                {
150
 
                  msg_error("Error creating syslog door file",
151
 
                            evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
152
 
                            evt_tag_errno(EVT_TAG_OSERROR, errno),
153
 
                            NULL);
154
 
                  close(fd);
155
 
                  return FALSE;
156
 
                }
157
 
            }
158
 
          fdetach(self->door_filename->str);
159
 
          self->door_fd = door_create(afstreams_sd_door_server_proc, NULL, 0);
160
 
          if (self->door_fd == -1)
161
 
            {
162
 
              msg_error("Error creating syslog door",
163
 
                        evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
164
 
                        evt_tag_errno(EVT_TAG_OSERROR, errno),
165
 
                        NULL);
166
 
              close(self->door_fd);
167
 
              return FALSE;
168
 
            }
169
 
          g_fd_set_cloexec(self->door_fd, TRUE);
170
 
          if (fattach(self->door_fd, self->door_filename->str) == -1)
171
 
            {
172
 
              msg_error("Error attaching syslog door",
173
 
                        evt_tag_str(EVT_TAG_FILENAME, self->door_filename->str),
174
 
                        evt_tag_errno(EVT_TAG_OSERROR, errno),
175
 
                        NULL);
176
 
              close(self->door_fd);
177
 
              return FALSE;
178
 
            }
 
194
          
 
195
          /* door creation is deferred, because it creates threads which is
 
196
           * not inherited through forks, and syslog-ng forks during
 
197
           * startup, but _after_ the configuration was initialized */
 
198
          
 
199
          register_application_hook(AH_POST_DAEMONIZED, afstreams_init_door, self);
179
200
        }
180
 
      if (!log_pipe_init(self->reader, NULL, NULL))
 
201
      if (!log_pipe_init(self->reader, NULL))
181
202
        {
182
203
          msg_error("Error initializing log_reader, closing fd",
183
204
                    evt_tag_int("fd", fd),
201
222
}
202
223
 
203
224
static gboolean
204
 
afstreams_sd_deinit(LogPipe *s, GlobalConfig *cfg, PersistentConfig *persist)
 
225
afstreams_sd_deinit(LogPipe *s)
205
226
{
206
227
  AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
207
228
 
208
229
  if (self->reader)
209
 
    log_pipe_deinit(self->reader, NULL, NULL);
210
 
  door_revoke(self->door_fd);
211
 
  close(self->door_fd);
 
230
    log_pipe_deinit(self->reader);
 
231
  if (self->door_fd != -1)
 
232
    {
 
233
      door_revoke(self->door_fd);
 
234
      close(self->door_fd);
 
235
    }
212
236
  return TRUE;
213
237
}
214
238
 
217
241
{
218
242
  AFStreamsSourceDriver *self = (AFStreamsSourceDriver *) s;
219
243
 
 
244
  log_reader_options_destroy(&self->reader_options);
220
245
  if (self->dev_filename)
221
246
    g_string_free(self->dev_filename, TRUE);
222
247
  if (self->door_filename)
223
248
    g_string_free(self->door_filename, TRUE);
224
249
  log_pipe_unref(self->reader);
225
250
 
226
 
  log_drv_free_instance(&self->super);
227
 
  g_free(s);
 
251
  log_drv_free(s);
228
252
}
229
253
 
230
254
LogDriver *
242
266
  return &self->super;
243
267
}
244
268
 
245
 
#else
246
 
 
247
 
void 
248
 
afstreams_sd_set_sundoor(LogDriver *self, gchar *filename)
249
 
{
250
 
}
251
 
 
252
 
LogDriver *
253
 
afstreams_sd_new(gchar *filename)
254
 
{
255
 
  AFStreamsSourceDriver *self = g_new0(AFStreamsSourceDriver, 1);
256
 
 
257
 
  msg_error("STREAMS support not compiled in", NULL);
258
 
  return &self->super;
259
 
}
260
 
 
261
269
#endif