← Back to branch summary

~ubuntu-branches/ubuntu/hardy/openssl/hardy-security

« back to all changes in this revision

Viewing changes to crypto/bio/bss_log.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Martin
  • Date: 2004-05-24 17:02:29 UTC
  • Revision ID: james.westby@ubuntu.com-20040524170229-ixlo08bbbly0xied
Tags: upstream-0.9.7d
Import upstream version 0.9.7d

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/bio/bss_log.c
 
1
/* crypto/bio/bss_log.c */
 
2
/* ====================================================================
 
3
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * 1. Redistributions of source code must retain the above copyright
 
10
 *    notice, this list of conditions and the following disclaimer. 
 
11
 *
 
12
 * 2. Redistributions in binary form must reproduce the above copyright
 
13
 *    notice, this list of conditions and the following disclaimer in
 
14
 *    the documentation and/or other materials provided with the
 
15
 *    distribution.
 
16
 *
 
17
 * 3. All advertising materials mentioning features or use of this
 
18
 *    software must display the following acknowledgment:
 
19
 *    "This product includes software developed by the OpenSSL Project
 
20
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 
21
 *
 
22
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 
23
 *    endorse or promote products derived from this software without
 
24
 *    prior written permission. For written permission, please contact
 
25
 *    licensing@OpenSSL.org.
 
26
 *
 
27
 * 5. Products derived from this software may not be called "OpenSSL"
 
28
 *    nor may "OpenSSL" appear in their names without prior written
 
29
 *    permission of the OpenSSL Project.
 
30
 *
 
31
 * 6. Redistributions of any form whatsoever must retain the following
 
32
 *    acknowledgment:
 
33
 *    "This product includes software developed by the OpenSSL Project
 
34
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 
35
 *
 
36
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 
37
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
38
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
39
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 
40
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
41
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
42
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
43
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
44
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
45
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
46
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
47
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
48
 * ====================================================================
 
49
 *
 
50
 * This product includes cryptographic software written by Eric Young
 
51
 * (eay@cryptsoft.com).  This product includes software written by Tim
 
52
 * Hudson (tjh@cryptsoft.com).
 
53
 *
 
54
 */
 
55
 
 
56
/*
 
57
        Why BIO_s_log?
 
58
 
 
59
        BIO_s_log is useful for system daemons (or services under NT).
 
60
        It is one-way BIO, it sends all stuff to syslogd (on system that
 
61
        commonly use that), or event log (on NT), or OPCOM (on OpenVMS).
 
62
 
 
63
*/
 
64
 
 
65
 
 
66
#include <stdio.h>
 
67
#include <errno.h>
 
68
 
 
69
#include "cryptlib.h"
 
70
 
 
71
#if defined(OPENSSL_SYS_WINCE)
 
72
#elif defined(OPENSSL_SYS_WIN32)
 
73
#  include <process.h>
 
74
#elif defined(OPENSSL_SYS_VMS)
 
75
#  include <opcdef.h>
 
76
#  include <descrip.h>
 
77
#  include <lib$routines.h>
 
78
#  include <starlet.h>
 
79
#elif defined(__ultrix)
 
80
#  include <sys/syslog.h>
 
81
#elif (!defined(MSDOS) || defined(WATT32)) && !defined(OPENSSL_SYS_VXWORKS) && !defined(NO_SYSLOG)
 
82
#  include <syslog.h>
 
83
#endif
 
84
 
 
85
#include <openssl/buffer.h>
 
86
#include <openssl/err.h>
 
87
 
 
88
#ifndef NO_SYSLOG
 
89
 
 
90
#if defined(OPENSSL_SYS_WIN32)
 
91
#define LOG_EMERG       0
 
92
#define LOG_ALERT       1
 
93
#define LOG_CRIT        2
 
94
#define LOG_ERR         3
 
95
#define LOG_WARNING     4
 
96
#define LOG_NOTICE      5
 
97
#define LOG_INFO        6
 
98
#define LOG_DEBUG       7
 
99
 
 
100
#define LOG_DAEMON      (3<<3)
 
101
#elif defined(OPENSSL_SYS_VMS)
 
102
/* On VMS, we don't really care about these, but we need them to compile */
 
103
#define LOG_EMERG       0
 
104
#define LOG_ALERT       1
 
105
#define LOG_CRIT        2
 
106
#define LOG_ERR         3
 
107
#define LOG_WARNING     4
 
108
#define LOG_NOTICE      5
 
109
#define LOG_INFO        6
 
110
#define LOG_DEBUG       7
 
111
 
 
112
#define LOG_DAEMON      OPC$M_NM_NTWORK
 
113
#endif
 
114
 
 
115
static int MS_CALLBACK slg_write(BIO *h, const char *buf, int num);
 
116
static int MS_CALLBACK slg_puts(BIO *h, const char *str);
 
117
static long MS_CALLBACK slg_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 
118
static int MS_CALLBACK slg_new(BIO *h);
 
119
static int MS_CALLBACK slg_free(BIO *data);
 
120
static void xopenlog(BIO* bp, char* name, int level);
 
121
static void xsyslog(BIO* bp, int priority, const char* string);
 
122
static void xcloselog(BIO* bp);
 
123
#ifdef OPENSSL_SYS_WIN32
 
124
LONG    (WINAPI *go_for_advapi)()       = RegOpenKeyEx;
 
125
HANDLE  (WINAPI *register_event_source)()       = NULL;
 
126
BOOL    (WINAPI *deregister_event_source)()     = NULL;
 
127
BOOL    (WINAPI *report_event)()        = NULL;
 
128
#define DL_PROC(m,f)    (GetProcAddress( m, f ))
 
129
#ifdef UNICODE
 
130
#define DL_PROC_X(m,f) DL_PROC( m, f "W" )
 
131
#else
 
132
#define DL_PROC_X(m,f) DL_PROC( m, f "A" )
 
133
#endif
 
134
#endif
 
135
 
 
136
static BIO_METHOD methods_slg=
 
137
        {
 
138
        BIO_TYPE_MEM,"syslog",
 
139
        slg_write,
 
140
        NULL,
 
141
        slg_puts,
 
142
        NULL,
 
143
        slg_ctrl,
 
144
        slg_new,
 
145
        slg_free,
 
146
        NULL,
 
147
        };
 
148
 
 
149
BIO_METHOD *BIO_s_log(void)
 
150
        {
 
151
        return(&methods_slg);
 
152
        }
 
153
 
 
154
static int MS_CALLBACK slg_new(BIO *bi)
 
155
        {
 
156
        bi->init=1;
 
157
        bi->num=0;
 
158
        bi->ptr=NULL;
 
159
        xopenlog(bi, "application", LOG_DAEMON);
 
160
        return(1);
 
161
        }
 
162
 
 
163
static int MS_CALLBACK slg_free(BIO *a)
 
164
        {
 
165
        if (a == NULL) return(0);
 
166
        xcloselog(a);
 
167
        return(1);
 
168
        }
 
169
        
 
170
static int MS_CALLBACK slg_write(BIO *b, const char *in, int inl)
 
171
        {
 
172
        int ret= inl;
 
173
        char* buf;
 
174
        char* pp;
 
175
        int priority, i;
 
176
        static struct
 
177
                {
 
178
                int strl;
 
179
                char str[10];
 
180
                int log_level;
 
181
                }
 
182
        mapping[] =
 
183
                {
 
184
                { 6, "PANIC ", LOG_EMERG },
 
185
                { 6, "EMERG ", LOG_EMERG },
 
186
                { 4, "EMR ", LOG_EMERG },
 
187
                { 6, "ALERT ", LOG_ALERT },
 
188
                { 4, "ALR ", LOG_ALERT },
 
189
                { 5, "CRIT ", LOG_CRIT },
 
190
                { 4, "CRI ", LOG_CRIT },
 
191
                { 6, "ERROR ", LOG_ERR },
 
192
                { 4, "ERR ", LOG_ERR },
 
193
                { 8, "WARNING ", LOG_WARNING },
 
194
                { 5, "WARN ", LOG_WARNING },
 
195
                { 4, "WAR ", LOG_WARNING },
 
196
                { 7, "NOTICE ", LOG_NOTICE },
 
197
                { 5, "NOTE ", LOG_NOTICE },
 
198
                { 4, "NOT ", LOG_NOTICE },
 
199
                { 5, "INFO ", LOG_INFO },
 
200
                { 4, "INF ", LOG_INFO },
 
201
                { 6, "DEBUG ", LOG_DEBUG },
 
202
                { 4, "DBG ", LOG_DEBUG },
 
203
                { 0, "", LOG_ERR } /* The default */
 
204
                };
 
205
 
 
206
        if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
 
207
                return(0);
 
208
        }
 
209
        strncpy(buf, in, inl);
 
210
        buf[inl]= '\0';
 
211
 
 
212
        i = 0;
 
213
        while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++;
 
214
        priority = mapping[i].log_level;
 
215
        pp = buf + mapping[i].strl;
 
216
 
 
217
        xsyslog(b, priority, pp);
 
218
 
 
219
        OPENSSL_free(buf);
 
220
        return(ret);
 
221
        }
 
222
 
 
223
static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, void *ptr)
 
224
        {
 
225
        switch (cmd)
 
226
                {
 
227
        case BIO_CTRL_SET:
 
228
                xcloselog(b);
 
229
                xopenlog(b, ptr, num);
 
230
                break;
 
231
        default:
 
232
                break;
 
233
                }
 
234
        return(0);
 
235
        }
 
236
 
 
237
static int MS_CALLBACK slg_puts(BIO *bp, const char *str)
 
238
        {
 
239
        int n,ret;
 
240
 
 
241
        n=strlen(str);
 
242
        ret=slg_write(bp,str,n);
 
243
        return(ret);
 
244
        }
 
245
 
 
246
#if defined(OPENSSL_SYS_WIN32)
 
247
 
 
248
static void xopenlog(BIO* bp, char* name, int level)
 
249
{
 
250
        if ( !register_event_source )
 
251
                {
 
252
                HANDLE  advapi;
 
253
                if ( !(advapi = GetModuleHandle("advapi32")) )
 
254
                        return;
 
255
                register_event_source = (HANDLE (WINAPI *)())DL_PROC_X(advapi,
 
256
                        "RegisterEventSource" );
 
257
                deregister_event_source = (BOOL (WINAPI *)())DL_PROC(advapi,
 
258
                        "DeregisterEventSource");
 
259
                report_event = (BOOL (WINAPI *)())DL_PROC_X(advapi,
 
260
                        "ReportEvent" );
 
261
                if ( !(register_event_source && deregister_event_source &&
 
262
                                report_event) )
 
263
                        {
 
264
                        register_event_source = NULL;
 
265
                        deregister_event_source = NULL;
 
266
                        report_event = NULL;
 
267
                        return;
 
268
                        }
 
269
                }
 
270
        bp->ptr= (char *)register_event_source(NULL, name);
 
271
}
 
272
 
 
273
static void xsyslog(BIO *bp, int priority, const char *string)
 
274
{
 
275
        LPCSTR lpszStrings[2];
 
276
        WORD evtype= EVENTLOG_ERROR_TYPE;
 
277
        int pid = _getpid();
 
278
        char pidbuf[DECIMAL_SIZE(pid)+4];
 
279
 
 
280
        switch (priority)
 
281
                {
 
282
        case LOG_EMERG:
 
283
        case LOG_ALERT:
 
284
        case LOG_CRIT:
 
285
        case LOG_ERR:
 
286
                evtype = EVENTLOG_ERROR_TYPE;
 
287
                break;
 
288
        case LOG_WARNING:
 
289
                evtype = EVENTLOG_WARNING_TYPE;
 
290
                break;
 
291
        case LOG_NOTICE:
 
292
        case LOG_INFO:
 
293
        case LOG_DEBUG:
 
294
                evtype = EVENTLOG_INFORMATION_TYPE;
 
295
                break;
 
296
        default:                /* Should never happen, but set it
 
297
                                   as error anyway. */
 
298
                evtype = EVENTLOG_ERROR_TYPE;
 
299
                break;
 
300
                }
 
301
 
 
302
        sprintf(pidbuf, "[%d] ", pid);
 
303
        lpszStrings[0] = pidbuf;
 
304
        lpszStrings[1] = string;
 
305
 
 
306
        if(report_event && bp->ptr)
 
307
                report_event(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
 
308
                                lpszStrings, NULL);
 
309
}
 
310
        
 
311
static void xcloselog(BIO* bp)
 
312
{
 
313
        if(deregister_event_source && bp->ptr)
 
314
                deregister_event_source((HANDLE)(bp->ptr));
 
315
        bp->ptr= NULL;
 
316
}
 
317
 
 
318
#elif defined(OPENSSL_SYS_VMS)
 
319
 
 
320
static int VMS_OPC_target = LOG_DAEMON;
 
321
 
 
322
static void xopenlog(BIO* bp, char* name, int level)
 
323
{
 
324
        VMS_OPC_target = level; 
 
325
}
 
326
 
 
327
static void xsyslog(BIO *bp, int priority, const char *string)
 
328
{
 
329
        struct dsc$descriptor_s opc_dsc;
 
330
        struct opcdef *opcdef_p;
 
331
        char buf[10240];
 
332
        unsigned int len;
 
333
        struct dsc$descriptor_s buf_dsc;
 
334
        $DESCRIPTOR(fao_cmd, "!AZ: !AZ");
 
335
        char *priority_tag;
 
336
 
 
337
        switch (priority)
 
338
          {
 
339
          case LOG_EMERG: priority_tag = "Emergency"; break;
 
340
          case LOG_ALERT: priority_tag = "Alert"; break;
 
341
          case LOG_CRIT: priority_tag = "Critical"; break;
 
342
          case LOG_ERR: priority_tag = "Error"; break;
 
343
          case LOG_WARNING: priority_tag = "Warning"; break;
 
344
          case LOG_NOTICE: priority_tag = "Notice"; break;
 
345
          case LOG_INFO: priority_tag = "Info"; break;
 
346
          case LOG_DEBUG: priority_tag = "DEBUG"; break;
 
347
          }
 
348
 
 
349
        buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
 
350
        buf_dsc.dsc$b_class = DSC$K_CLASS_S;
 
351
        buf_dsc.dsc$a_pointer = buf;
 
352
        buf_dsc.dsc$w_length = sizeof(buf) - 1;
 
353
 
 
354
        lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
 
355
 
 
356
        /* we know there's an 8 byte header.  That's documented */
 
357
        opcdef_p = (struct opcdef *) OPENSSL_malloc(8 + len);
 
358
        opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
 
359
        memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
 
360
        opcdef_p->opc$l_ms_rqstid = 0;
 
361
        memcpy(&opcdef_p->opc$l_ms_text, buf, len);
 
362
 
 
363
        opc_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
 
364
        opc_dsc.dsc$b_class = DSC$K_CLASS_S;
 
365
        opc_dsc.dsc$a_pointer = (char *)opcdef_p;
 
366
        opc_dsc.dsc$w_length = len + 8;
 
367
 
 
368
        sys$sndopr(opc_dsc, 0);
 
369
 
 
370
        OPENSSL_free(opcdef_p);
 
371
}
 
372
 
 
373
static void xcloselog(BIO* bp)
 
374
{
 
375
}
 
376
 
 
377
#else /* Unix/Watt32 */
 
378
 
 
379
static void xopenlog(BIO* bp, char* name, int level)
 
380
{
 
381
#ifdef WATT32   /* djgpp/DOS */
 
382
        openlog(name, LOG_PID|LOG_CONS|LOG_NDELAY, level);
 
383
#else
 
384
        openlog(name, LOG_PID|LOG_CONS, level);
 
385
#endif
 
386
}
 
387
 
 
388
static void xsyslog(BIO *bp, int priority, const char *string)
 
389
{
 
390
        syslog(priority, "%s", string);
 
391
}
 
392
 
 
393
static void xcloselog(BIO* bp)
 
394
{
 
395
        closelog();
 
396
}
 
397
 
 
398
#endif /* Unix */
 
399
 
 
400
#endif /* NO_SYSLOG */