#include <stdio.h>
#include <errno.h>
-#if defined(WIN32)
+#include <openssl/e_os2.h>
+
+#if defined(OPENSSL_SYS_WIN32)
# include <process.h>
-#elif defined(VMS) || defined(__VMS)
+#elif defined(OPENSSL_SYS_VMS)
# include <opcdef.h>
# include <descrip.h>
# include <lib$routines.h>
# include <starlet.h>
#elif defined(__ultrix)
# include <sys/syslog.h>
-#elif !defined(MSDOS) /* Unix */
+#elif !defined(MSDOS) && !defined(NO_SYSLOG) /* Unix */
# include <syslog.h>
#endif
#ifndef NO_SYSLOG
-#if defined(WIN32)
+#if defined(OPENSSL_SYS_WIN32)
#define LOG_EMERG 0
#define LOG_ALERT 1
#define LOG_CRIT 2
#define LOG_DEBUG 7
#define LOG_DAEMON (3<<3)
-#elif defined(VMS)
+#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_DAEMON OPC$M_NM_NTWORK
#endif
-static int MS_CALLBACK slg_write(BIO *h,char *buf,int num);
-static int MS_CALLBACK slg_puts(BIO *h,char *str);
-static long MS_CALLBACK slg_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int MS_CALLBACK slg_write(BIO *h, const char *buf, int num);
+static int MS_CALLBACK slg_puts(BIO *h, const char *str);
+static long MS_CALLBACK slg_ctrl(BIO *h, int cmd, long arg1, void *arg2);
static int MS_CALLBACK slg_new(BIO *h);
static int MS_CALLBACK slg_free(BIO *data);
-static void xopenlog(BIO* bp, const char* name, int level);
+static void xopenlog(BIO* bp, char* name, int level);
static void xsyslog(BIO* bp, int priority, const char* string);
static void xcloselog(BIO* bp);
+#ifdef OPENSSL_SYS_WIN32
+LONG (WINAPI *go_for_advapi)() = RegOpenKeyEx;
+HANDLE (WINAPI *register_event_source)() = NULL;
+BOOL (WINAPI *deregister_event_source)() = NULL;
+BOOL (WINAPI *report_event)() = NULL;
+#define DL_PROC(m,f) (GetProcAddress( m, f ))
+#ifdef UNICODE
+#define DL_PROC_X(m,f) DL_PROC( m, f "W" )
+#else
+#define DL_PROC_X(m,f) DL_PROC( m, f "A" )
+#endif
+#endif
static BIO_METHOD methods_slg=
{
return(1);
}
-static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
+static int MS_CALLBACK slg_write(BIO *b, const char *in, int inl)
{
int ret= inl;
- char* buf= in;
+ char* buf;
char* pp;
- int priority;
-
- if((buf= (char *)Malloc(inl+ 1)) == NULL){
+ int priority, i;
+ static 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';
- if(strncmp(buf, "ERR ", 4) == 0){
- priority= LOG_ERR;
- pp= buf+ 4;
- }else if(strncmp(buf, "WAR ", 4) == 0){
- priority= LOG_WARNING;
- pp= buf+ 4;
- }else if(strncmp(buf, "INF ", 4) == 0){
- priority= LOG_INFO;
- pp= buf+ 4;
- }else{
- priority= LOG_ERR;
- pp= buf;
- }
+ 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);
- Free(buf);
+ OPENSSL_free(buf);
return(ret);
}
-static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, char *ptr)
+static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, void *ptr)
{
switch (cmd)
{
return(0);
}
-static int MS_CALLBACK slg_puts(BIO *bp, char *str)
+static int MS_CALLBACK slg_puts(BIO *bp, const char *str)
{
int n,ret;
return(ret);
}
-#if defined(WIN32)
+#if defined(OPENSSL_SYS_WIN32)
-static void xopenlog(BIO* bp, const char* name, int level)
+static void xopenlog(BIO* bp, char* name, int level)
{
- bp->ptr= (char *)RegisterEventSource(NULL, name);
+ if ( !register_event_source )
+ {
+ HANDLE advapi;
+ if ( !(advapi = GetModuleHandle("advapi32")) )
+ return;
+ register_event_source = (HANDLE (WINAPI *)())DL_PROC_X(advapi,
+ "RegisterEventSource" );
+ deregister_event_source = (BOOL (WINAPI *)())DL_PROC(advapi,
+ "DeregisterEventSource");
+ report_event = (BOOL (WINAPI *)())DL_PROC_X(advapi,
+ "ReportEvent" );
+ if ( !(register_event_source && deregister_event_source &&
+ report_event) )
+ {
+ register_event_source = NULL;
+ deregister_event_source = NULL;
+ report_event = NULL;
+ return;
+ }
+ }
+ bp->ptr= (char *)register_event_source(NULL, name);
}
static void xsyslog(BIO *bp, int priority, const char *string)
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:
+ default: /* Should never happen, but set it
+ as error anyway. */
evtype = EVENTLOG_ERROR_TYPE;
break;
}
lpszStrings[0] = pidbuf;
lpszStrings[1] = string;
- if(bp->ptr)
- ReportEvent(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
+ if(report_event && bp->ptr)
+ report_event(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
lpszStrings, NULL);
}
static void xcloselog(BIO* bp)
{
- if(bp->ptr)
- DeregisterEventSource((HANDLE)(bp->ptr));
+ if(deregister_event_source && bp->ptr)
+ deregister_event_source((HANDLE)(bp->ptr));
bp->ptr= NULL;
}
-#elif defined(VMS)
+#elif defined(OPENSSL_SYS_VMS)
-static int VMS_OPC_target = OPC$M_NM_NTWORK;
+static int VMS_OPC_target = LOG_DAEMON;
-static void xopenlog(BIO* bp, const char* name, int level)
+static void xopenlog(BIO* bp, char* name, int level)
{
VMS_OPC_target = level;
}
char buf[10240];
unsigned int len;
struct dsc$descriptor_s buf_dsc;
- $DESCRIPTOR(fao_cmd, "!AZ");
+ $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, string);
+ lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
- /* we knoe there's an 8 byte header. That's documented */
- opcdef_p = (struct opcdef *) Malloc(8 + strlen(s));
+ /* we know there's an 8 byte header. That's documented */
+ opcdef_p = (struct opcdef *) OPENSSL_malloc(8 + len);
opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
- opcdef_p->opc$b_ms_target = VMS_OPC_target;
- memcpy(opcdef_p->opc$b_ms_target, &priority, 3);
+ 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_p;
+ opc_dsc.dsc$a_pointer = (char *)opcdef_p;
opc_dsc.dsc$w_length = len + 8;
- sys$sndopc(opc_dsc, 0);
+ sys$sndopr(opc_dsc, 0);
- Free(opcdef_p);
+ OPENSSL_free(opcdef_p);
}
static void xcloselog(BIO* bp)
#else /* Unix */
-static void xopenlog(BIO* bp, const char* name, int level)
+static void xopenlog(BIO* bp, char* name, int level)
{
openlog(name, LOG_PID|LOG_CONS, level);
}
projects / openssl.git / blobdiff