[thirdparty/openssl.git] / crypto / bio / bss_log.c

/* crypto/bio/bss_log.c */
/* ====================================================================
 * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */

/*
	Why BIO_s_log?

	BIO_s_log is useful for system daemons (or services under NT).
	It is one-way BIO, it sends all stuff to syslogd (on system that
	commonly use that), or event log (on NT), or OPCOM (on OpenVMS).

*/


#include <stdio.h>
#include <errno.h>

#include "cryptlib.h"

#if defined(OPENSSL_SYS_WINCE)
#elif defined(OPENSSL_SYS_WIN32)
#elif defined(OPENSSL_SYS_VMS)
#  include <opcdef.h>
#  include <descrip.h>
#  include <lib$routines.h>
#  include <starlet.h>
/* Some compiler options may mask the declaration of "_malloc32". */
#  if __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE
#    if __INITIAL_POINTER_SIZE == 64
#      pragma pointer_size save
#      pragma pointer_size 32
    void * _malloc32  (__size_t);
#      pragma pointer_size restore
#    endif /* __INITIAL_POINTER_SIZE == 64 */
#  endif /* __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE */
#elif defined(__ultrix)
#  include <sys/syslog.h>
#elif defined(OPENSSL_SYS_NETWARE)
#  define NO_SYSLOG
#elif (!defined(MSDOS) || defined(WATT32)) && !defined(OPENSSL_SYS_VXWORKS) && !defined(NO_SYSLOG)
#  include <syslog.h>
#endif

#include <openssl/buffer.h>
#include <openssl/err.h>

#ifndef NO_SYSLOG

#if defined(OPENSSL_SYS_WIN32)
#define LOG_EMERG	0
#define LOG_ALERT	1
#define LOG_CRIT	2
#define LOG_ERR		3
#define LOG_WARNING	4
#define LOG_NOTICE	5
#define LOG_INFO	6
#define LOG_DEBUG	7

#define LOG_DAEMON	(3<<3)
#elif defined(OPENSSL_SYS_VMS)
/* On VMS, we don't really care about these, but we need them to compile */
#define LOG_EMERG	0
#define LOG_ALERT	1
#define LOG_CRIT	2
#define LOG_ERR		3
#define LOG_WARNING	4
#define LOG_NOTICE	5
#define LOG_INFO	6
#define LOG_DEBUG	7

#define LOG_DAEMON	OPC$M_NM_NTWORK
#endif

static int slg_write(BIO *h, const char *buf, int num);
static int slg_puts(BIO *h, const char *str);
static long slg_ctrl(BIO *h, int cmd, long arg1, void *arg2);
static int slg_new(BIO *h);
static int slg_free(BIO *data);
static void xopenlog(BIO* bp, char* name, int level);
static void xsyslog(BIO* bp, int priority, const char* string);
static void xcloselog(BIO* bp);

static BIO_METHOD methods_slg=
	{
	BIO_TYPE_MEM,"syslog",
	slg_write,
	NULL,
	slg_puts,
	NULL,
	slg_ctrl,
	slg_new,
	slg_free,
	NULL,
	};

BIO_METHOD *BIO_s_log(void)
	{
	return(&methods_slg);
	}

static int slg_new(BIO *bi)
	{
	bi->init=1;
	bi->num=0;
	bi->ptr=NULL;
	xopenlog(bi, "application", LOG_DAEMON);
	return(1);
	}

static int slg_free(BIO *a)
	{
	if (a == NULL) return(0);
	xcloselog(a);
	return(1);
	}
	
static int slg_write(BIO *b, const char *in, int inl)
	{
	int ret= inl;
	char* buf;
	char* pp;
	int priority, i;
	static const struct
		{
		int strl;
		char str[10];
		int log_level;
		}
	mapping[] =
		{
		{ 6, "PANIC ", LOG_EMERG },
		{ 6, "EMERG ", LOG_EMERG },
		{ 4, "EMR ", LOG_EMERG },
		{ 6, "ALERT ", LOG_ALERT },
		{ 4, "ALR ", LOG_ALERT },
		{ 5, "CRIT ", LOG_CRIT },
		{ 4, "CRI ", LOG_CRIT },
		{ 6, "ERROR ", LOG_ERR },
		{ 4, "ERR ", LOG_ERR },
		{ 8, "WARNING ", LOG_WARNING },
		{ 5, "WARN ", LOG_WARNING },
		{ 4, "WAR ", LOG_WARNING },
		{ 7, "NOTICE ", LOG_NOTICE },
		{ 5, "NOTE ", LOG_NOTICE },
		{ 4, "NOT ", LOG_NOTICE },
		{ 5, "INFO ", LOG_INFO },
		{ 4, "INF ", LOG_INFO },
		{ 6, "DEBUG ", LOG_DEBUG },
		{ 4, "DBG ", LOG_DEBUG },
		{ 0, "", LOG_ERR } /* The default */
		};

	if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
		return(0);
	}
	strncpy(buf, in, inl);
	buf[inl]= '\0';

	i = 0;
	while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++;
	priority = mapping[i].log_level;
	pp = buf + mapping[i].strl;

	xsyslog(b, priority, pp);

	OPENSSL_free(buf);
	return(ret);
	}

static long slg_ctrl(BIO *b, int cmd, long num, void *ptr)
	{
	switch (cmd)
		{
	case BIO_CTRL_SET:
		xcloselog(b);
		xopenlog(b, ptr, num);
		break;
	default:
		break;
		}
	return(0);
	}

static int slg_puts(BIO *bp, const char *str)
	{
	int n,ret;

	n=strlen(str);
	ret=slg_write(bp,str,n);
	return(ret);
	}

#if defined(OPENSSL_SYS_WIN32)

static void xopenlog(BIO* bp, char* name, int level)
{
	if (check_winnt())
		bp->ptr = RegisterEventSourceA(NULL,name);
	else
		bp->ptr = NULL;
}

static void xsyslog(BIO *bp, int priority, const char *string)
{
	LPCSTR lpszStrings[2];
	WORD evtype= EVENTLOG_ERROR_TYPE;
	char pidbuf[DECIMAL_SIZE(DWORD)+4];

	if (bp->ptr == NULL)
		return;

	switch (priority)
		{
	case LOG_EMERG:
	case LOG_ALERT:
	case LOG_CRIT:
	case LOG_ERR:
		evtype = EVENTLOG_ERROR_TYPE;
		break;
	case LOG_WARNING:
		evtype = EVENTLOG_WARNING_TYPE;
		break;
	case LOG_NOTICE:
	case LOG_INFO:
	case LOG_DEBUG:
		evtype = EVENTLOG_INFORMATION_TYPE;
		break;
	default:
		/*
		 * Should never happen, but set it
		 * as error anyway.
		 */
		evtype = EVENTLOG_ERROR_TYPE;
		break;
		}

	sprintf(pidbuf, "[%u] ", GetCurrentProcessId());
	lpszStrings[0] = pidbuf;
	lpszStrings[1] = string;

	ReportEventA(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
				lpszStrings, NULL);
}
	
static void xcloselog(BIO* bp)
{
	if(bp->ptr)
		DeregisterEventSource((HANDLE)(bp->ptr));
	bp->ptr= NULL;
}

#elif defined(OPENSSL_SYS_VMS)

static int VMS_OPC_target = LOG_DAEMON;

static void xopenlog(BIO* bp, char* name, int level)
{
	VMS_OPC_target = level; 
}

static void xsyslog(BIO *bp, int priority, const char *string)
{
	struct dsc$descriptor_s opc_dsc;

/* Arrange 32-bit pointer to opcdef buffer and malloc(), if needed. */
#if __INITIAL_POINTER_SIZE == 64
# pragma pointer_size save
# pragma pointer_size 32
# define OPCDEF_TYPE __char_ptr32
# define OPCDEF_MALLOC _malloc32
#else /* __INITIAL_POINTER_SIZE == 64 */
# define OPCDEF_TYPE char *
# define OPCDEF_MALLOC OPENSSL_malloc
#endif /* __INITIAL_POINTER_SIZE == 64 [else] */

	struct opcdef *opcdef_p;

#if __INITIAL_POINTER_SIZE == 64
# pragma pointer_size restore
#endif /* __INITIAL_POINTER_SIZE == 64 */

	char buf[10240];
	unsigned int len;
        struct dsc$descriptor_s buf_dsc;
	$DESCRIPTOR(fao_cmd, "!AZ: !AZ");
	char *priority_tag;

	switch (priority)
	  {
	  case LOG_EMERG: priority_tag = "Emergency"; break;
	  case LOG_ALERT: priority_tag = "Alert"; break;
	  case LOG_CRIT: priority_tag = "Critical"; break;
	  case LOG_ERR: priority_tag = "Error"; break;
	  case LOG_WARNING: priority_tag = "Warning"; break;
	  case LOG_NOTICE: priority_tag = "Notice"; break;
	  case LOG_INFO: priority_tag = "Info"; break;
	  case LOG_DEBUG: priority_tag = "DEBUG"; break;
	  }

	buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
	buf_dsc.dsc$b_class = DSC$K_CLASS_S;
	buf_dsc.dsc$a_pointer = buf;
	buf_dsc.dsc$w_length = sizeof(buf) - 1;

	lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);

	/* We know there's an 8-byte header.  That's documented. */
	opcdef_p = OPCDEF_MALLOC( 8+ len);
	opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
	memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
	opcdef_p->opc$l_ms_rqstid = 0;
	memcpy(&opcdef_p->opc$l_ms_text, buf, len);

	opc_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
	opc_dsc.dsc$b_class = DSC$K_CLASS_S;
	opc_dsc.dsc$a_pointer = (OPCDEF_TYPE) opcdef_p;
	opc_dsc.dsc$w_length = len + 8;

	sys$sndopr(opc_dsc, 0);

	OPENSSL_free(opcdef_p);
}

static void xcloselog(BIO* bp)
{
}

#else /* Unix/Watt32 */

static void xopenlog(BIO* bp, char* name, int level)
{
#ifdef WATT32   /* djgpp/DOS */
	openlog(name, LOG_PID|LOG_CONS|LOG_NDELAY, level);
#else
	openlog(name, LOG_PID|LOG_CONS, level);
#endif
}

static void xsyslog(BIO *bp, int priority, const char *string)
{
	syslog(priority, "%s", string);
}

static void xcloselog(BIO* bp)
{
	closelog();
}

#endif /* Unix */

#endif /* NO_SYSLOG */
Commit	Line	Data
0849d138 BL	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).
84339237 RL	60	It is one-way BIO, it sends all stuff to syslogd (on system that
84339237 RL	61	commonly use that), or event log (on NT), or OPCOM (on OpenVMS).
0849d138 BL	62
	63	*/
	64
06c68491	65
0849d138 BL	66	#include <stdio.h>
	67	#include <errno.h>
	68
72b1072f	69	#include "cryptlib.h"
bc36ee62	70
0bf23d9b RL	71	#if defined(OPENSSL_SYS_WINCE)
0bf23d9b RL	72	#elif defined(OPENSSL_SYS_WIN32)
bc36ee62	73	#elif defined(OPENSSL_SYS_VMS)
153a59f4 UM	74	# include <opcdef.h>
153a59f4 UM	75	# include <descrip.h>
2d708bf6 RL	76	# include <lib$routines.h>
2d708bf6 RL	77	# include <starlet.h>
537c9823 RL	78	/* Some compiler options may mask the declaration of "_malloc32". */
	79	# if __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE
	80	# if __INITIAL_POINTER_SIZE == 64
	81	# pragma pointer_size save
	82	# pragma pointer_size 32
	83	void * _malloc32 (__size_t);
	84	# pragma pointer_size restore
	85	# endif /* __INITIAL_POINTER_SIZE == 64 */
	86	# endif /* __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE */
84339237	87	#elif defined(__ultrix)
153a59f4	88	# include <sys/syslog.h>
4d8743f4 RL	89	#elif defined(OPENSSL_SYS_NETWARE)
4d8743f4 RL	90	# define NO_SYSLOG
f642ebc1	91	#elif (!defined(MSDOS) \|\| defined(WATT32)) && !defined(OPENSSL_SYS_VXWORKS) && !defined(NO_SYSLOG)
153a59f4	92	# include <syslog.h>
0849d138 BL	93	#endif
0849d138 BL	94
ec577822 BM	95	#include <openssl/buffer.h>
ec577822 BM	96	#include <openssl/err.h>
153a59f4	97
6e064240 DSH	98	#ifndef NO_SYSLOG
6e064240 DSH	99
bc36ee62	100	#if defined(OPENSSL_SYS_WIN32)
84339237 RL	101	#define LOG_EMERG 0
	102	#define LOG_ALERT 1
	103	#define LOG_CRIT 2
	104	#define LOG_ERR 3
	105	#define LOG_WARNING 4
	106	#define LOG_NOTICE 5
	107	#define LOG_INFO 6
	108	#define LOG_DEBUG 7
	109
	110	#define LOG_DAEMON (3<<3)
bc36ee62	111	#elif defined(OPENSSL_SYS_VMS)
84339237 RL	112	/* On VMS, we don't really care about these, but we need them to compile */
	113	#define LOG_EMERG 0
	114	#define LOG_ALERT 1
	115	#define LOG_CRIT 2
	116	#define LOG_ERR 3
	117	#define LOG_WARNING 4
	118	#define LOG_NOTICE 5
	119	#define LOG_INFO 6
	120	#define LOG_DEBUG 7
	121
	122	#define LOG_DAEMON OPC$M_NM_NTWORK
	123	#endif
0849d138	124
6d23cf97 RS	125	static int slg_write(BIO h, const char buf, int num);
	126	static int slg_puts(BIO h, const char str);
	127	static long slg_ctrl(BIO h, int cmd, long arg1, void arg2);
	128	static int slg_new(BIO *h);
	129	static int slg_free(BIO *data);
ea58130d	130	static void xopenlog(BIO* bp, char* name, int level);
84339237 RL	131	static void xsyslog(BIO* bp, int priority, const char* string);
84339237 RL	132	static void xcloselog(BIO* bp);
0849d138 BL	133
	134	static BIO_METHOD methods_slg=
	135	{
	136	BIO_TYPE_MEM,"syslog",
	137	slg_write,
	138	NULL,
	139	slg_puts,
	140	NULL,
	141	slg_ctrl,
	142	slg_new,
	143	slg_free,
d3442bc7	144	NULL,
0849d138 BL	145	};
0849d138 BL	146
6b691a5c	147	BIO_METHOD *BIO_s_log(void)
0849d138 BL	148	{
	149	return(&methods_slg);
	150	}
	151
6d23cf97	152	static int slg_new(BIO *bi)
0849d138 BL	153	{
	154	bi->init=1;
	155	bi->num=0;
	156	bi->ptr=NULL;
0849d138	157	xopenlog(bi, "application", LOG_DAEMON);
0849d138 BL	158	return(1);
	159	}
	160
6d23cf97	161	static int slg_free(BIO *a)
0849d138 BL	162	{
	163	if (a == NULL) return(0);
	164	xcloselog(a);
	165	return(1);
	166	}
	167
6d23cf97	168	static int slg_write(BIO b, const char in, int inl)
0849d138 BL	169	{
0849d138 BL	170	int ret= inl;
0e1c0612	171	char* buf;
0849d138	172	char* pp;
0f4e2136	173	int priority, i;
ebc06fba	174	static const struct
0f4e2136 RL	175	{
	176	int strl;
	177	char str[10];
	178	int log_level;
	179	}
	180	mapping[] =
	181	{
	182	{ 6, "PANIC ", LOG_EMERG },
	183	{ 6, "EMERG ", LOG_EMERG },
	184	{ 4, "EMR ", LOG_EMERG },
	185	{ 6, "ALERT ", LOG_ALERT },
	186	{ 4, "ALR ", LOG_ALERT },
	187	{ 5, "CRIT ", LOG_CRIT },
	188	{ 4, "CRI ", LOG_CRIT },
	189	{ 6, "ERROR ", LOG_ERR },
	190	{ 4, "ERR ", LOG_ERR },
	191	{ 8, "WARNING ", LOG_WARNING },
	192	{ 5, "WARN ", LOG_WARNING },
	193	{ 4, "WAR ", LOG_WARNING },
	194	{ 7, "NOTICE ", LOG_NOTICE },
	195	{ 5, "NOTE ", LOG_NOTICE },
	196	{ 4, "NOT ", LOG_NOTICE },
	197	{ 5, "INFO ", LOG_INFO },
	198	{ 4, "INF ", LOG_INFO },
	199	{ 6, "DEBUG ", LOG_DEBUG },
	200	{ 4, "DBG ", LOG_DEBUG },
	201	{ 0, "", LOG_ERR } /* The default */
	202	};
0849d138	203
26a3a48d	204	if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
0849d138 BL	205	return(0);
	206	}
	207	strncpy(buf, in, inl);
	208	buf[inl]= '\0';
0849d138	209
0f4e2136 RL	210	i = 0;
	211	while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++;
	212	priority = mapping[i].log_level;
	213	pp = buf + mapping[i].strl;
0849d138	214
84339237 RL	215	xsyslog(b, priority, pp);
84339237 RL	216
26a3a48d	217	OPENSSL_free(buf);
0849d138 BL	218	return(ret);
	219	}
	220
6d23cf97	221	static long slg_ctrl(BIO b, int cmd, long num, void ptr)
0849d138 BL	222	{
	223	switch (cmd)
	224	{
	225	case BIO_CTRL_SET:
	226	xcloselog(b);
	227	xopenlog(b, ptr, num);
	228	break;
	229	default:
	230	break;
	231	}
	232	return(0);
	233	}
	234
6d23cf97	235	static int slg_puts(BIO bp, const char str)
0849d138 BL	236	{
	237	int n,ret;
	238
	239	n=strlen(str);
	240	ret=slg_write(bp,str,n);
	241	return(ret);
	242	}
	243
bc36ee62	244	#if defined(OPENSSL_SYS_WIN32)
84339237	245
ea58130d	246	static void xopenlog(BIO* bp, char* name, int level)
84339237	247	{
a4cc3c80	248	if (check_winnt())
befe1fbc AP	249	bp->ptr = RegisterEventSourceA(NULL,name);
	250	else
	251	bp->ptr = NULL;
0849d138 BL	252	}
0849d138 BL	253
84339237 RL	254	static void xsyslog(BIO bp, int priority, const char string)
	255	{
	256	LPCSTR lpszStrings[2];
	257	WORD evtype= EVENTLOG_ERROR_TYPE;
befe1fbc AP	258	char pidbuf[DECIMAL_SIZE(DWORD)+4];
	259
	260	if (bp->ptr == NULL)
	261	return;
84339237 RL	262
	263	switch (priority)
	264	{
0f4e2136 RL	265	case LOG_EMERG:
	266	case LOG_ALERT:
	267	case LOG_CRIT:
84339237 RL	268	case LOG_ERR:
	269	evtype = EVENTLOG_ERROR_TYPE;
	270	break;
	271	case LOG_WARNING:
	272	evtype = EVENTLOG_WARNING_TYPE;
	273	break;
0f4e2136	274	case LOG_NOTICE:
84339237	275	case LOG_INFO:
0f4e2136	276	case LOG_DEBUG:
84339237 RL	277	evtype = EVENTLOG_INFORMATION_TYPE;
84339237 RL	278	break;
dbd87ffc MC	279	default:
	280	/*
	281	* Should never happen, but set it
	282	* as error anyway.
	283	*/
84339237 RL	284	evtype = EVENTLOG_ERROR_TYPE;
	285	break;
	286	}
	287
befe1fbc	288	sprintf(pidbuf, "[%u] ", GetCurrentProcessId());
84339237	289	lpszStrings[0] = pidbuf;
153a59f4	290	lpszStrings[1] = string;
84339237	291
befe1fbc	292	ReportEventA(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
84339237	293	lpszStrings, NULL);
84339237 RL	294	}
	295
	296	static void xcloselog(BIO* bp)
0849d138	297	{
befe1fbc AP	298	if(bp->ptr)
befe1fbc AP	299	DeregisterEventSource((HANDLE)(bp->ptr));
0849d138	300	bp->ptr= NULL;
84339237 RL	301	}
84339237 RL	302
bc36ee62	303	#elif defined(OPENSSL_SYS_VMS)
84339237	304
158ef048	305	static int VMS_OPC_target = LOG_DAEMON;
84339237	306
ea58130d	307	static void xopenlog(BIO* bp, char* name, int level)
84339237 RL	308	{
	309	VMS_OPC_target = level;
	310	}
	311
008fee38	312	static void xsyslog(BIO bp, int priority, const char string)
84339237	313	{
2d708bf6	314	struct dsc$descriptor_s opc_dsc;
537c9823 RL	315
	316	/* Arrange 32-bit pointer to opcdef buffer and malloc(), if needed. */
	317	#if __INITIAL_POINTER_SIZE == 64
	318	# pragma pointer_size save
	319	# pragma pointer_size 32
	320	# define OPCDEF_TYPE __char_ptr32
	321	# define OPCDEF_MALLOC _malloc32
	322	#else /* __INITIAL_POINTER_SIZE == 64 */
	323	# define OPCDEF_TYPE char *
	324	# define OPCDEF_MALLOC OPENSSL_malloc
	325	#endif /* __INITIAL_POINTER_SIZE == 64 [else] */
	326
84339237	327	struct opcdef *opcdef_p;
537c9823 RL	328
	329	#if __INITIAL_POINTER_SIZE == 64
	330	# pragma pointer_size restore
	331	#endif /* __INITIAL_POINTER_SIZE == 64 */
	332
84339237 RL	333	char buf[10240];
84339237 RL	334	unsigned int len;
2d708bf6	335	struct dsc$descriptor_s buf_dsc;
158ef048 RL	336	$DESCRIPTOR(fao_cmd, "!AZ: !AZ");
	337	char *priority_tag;
	338
	339	switch (priority)
	340	{
	341	case LOG_EMERG: priority_tag = "Emergency"; break;
	342	case LOG_ALERT: priority_tag = "Alert"; break;
	343	case LOG_CRIT: priority_tag = "Critical"; break;
	344	case LOG_ERR: priority_tag = "Error"; break;
	345	case LOG_WARNING: priority_tag = "Warning"; break;
	346	case LOG_NOTICE: priority_tag = "Notice"; break;
	347	case LOG_INFO: priority_tag = "Info"; break;
	348	case LOG_DEBUG: priority_tag = "DEBUG"; break;
	349	}
84339237	350
2d708bf6 RL	351	buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
	352	buf_dsc.dsc$b_class = DSC$K_CLASS_S;
	353	buf_dsc.dsc$a_pointer = buf;
	354	buf_dsc.dsc$w_length = sizeof(buf) - 1;
	355
158ef048	356	lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
84339237	357
537c9823 RL	358	/* We know there's an 8-byte header. That's documented. */
537c9823 RL	359	opcdef_p = OPCDEF_MALLOC( 8+ len);
84339237	360	opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
158ef048	361	memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
84339237 RL	362	opcdef_p->opc$l_ms_rqstid = 0;
	363	memcpy(&opcdef_p->opc$l_ms_text, buf, len);
	364
	365	opc_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
	366	opc_dsc.dsc$b_class = DSC$K_CLASS_S;
537c9823	367	opc_dsc.dsc$a_pointer = (OPCDEF_TYPE) opcdef_p;
84339237 RL	368	opc_dsc.dsc$w_length = len + 8;
84339237 RL	369
d8779db4	370	sys$sndopr(opc_dsc, 0);
84339237	371
26a3a48d	372	OPENSSL_free(opcdef_p);
84339237 RL	373	}
	374
	375	static void xcloselog(BIO* bp)
	376	{
	377	}
	378
f642ebc1	379	#else /* Unix/Watt32 */
84339237	380
ea58130d	381	static void xopenlog(BIO* bp, char* name, int level)
84339237	382	{
f642ebc1 RS	383	#ifdef WATT32 /* djgpp/DOS */
	384	openlog(name, LOG_PID\|LOG_CONS\|LOG_NDELAY, level);
	385	#else
ea58130d	386	openlog(name, LOG_PID\|LOG_CONS, level);
f642ebc1	387	#endif
84339237 RL	388	}
	389
	390	static void xsyslog(BIO bp, int priority, const char string)
	391	{
	392	syslog(priority, "%s", string);
	393	}
	394
	395	static void xcloselog(BIO* bp)
	396	{
0849d138	397	closelog();
0849d138 BL	398	}
0849d138 BL	399
153a59f4	400	#endif /* Unix */
84339237	401
153a59f4	402	#endif /* NO_SYSLOG */