| OLD | NEW |
|---|
| (Empty) |
| 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 #elif defined(OPENSSL_SYS_VMS) | |
| 74 # include <opcdef.h> | |
| 75 # include <descrip.h> | |
| 76 # include <lib$routines.h> | |
| 77 # include <starlet.h> | |
| 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 */ | |
| 87 #elif defined(__ultrix) | |
| 88 # include <sys/syslog.h> | |
| 89 #elif defined(OPENSSL_SYS_NETWARE) | |
| 90 # define NO_SYSLOG | |
| 91 #elif (!defined(MSDOS) || defined(WATT32)) && !defined(OPENSSL_SYS_VXWORKS) && !
defined(NO_SYSLOG) | |
| 92 # include <syslog.h> | |
| 93 #endif | |
| 94 | |
| 95 #include <openssl/buffer.h> | |
| 96 #include <openssl/err.h> | |
| 97 | |
| 98 #ifndef NO_SYSLOG | |
| 99 | |
| 100 #if defined(OPENSSL_SYS_WIN32) | |
| 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) | |
| 111 #elif defined(OPENSSL_SYS_VMS) | |
| 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 | |
| 124 | |
| 125 static int MS_CALLBACK slg_write(BIO *h, const char *buf, int num); | |
| 126 static int MS_CALLBACK slg_puts(BIO *h, const char *str); | |
| 127 static long MS_CALLBACK slg_ctrl(BIO *h, int cmd, long arg1, void *arg2); | |
| 128 static int MS_CALLBACK slg_new(BIO *h); | |
| 129 static int MS_CALLBACK slg_free(BIO *data); | |
| 130 static void xopenlog(BIO* bp, char* name, int level); | |
| 131 static void xsyslog(BIO* bp, int priority, const char* string); | |
| 132 static void xcloselog(BIO* bp); | |
| 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, | |
| 144 NULL, | |
| 145 }; | |
| 146 | |
| 147 BIO_METHOD *BIO_s_log(void) | |
| 148 { | |
| 149 return(&methods_slg); | |
| 150 } | |
| 151 | |
| 152 static int MS_CALLBACK slg_new(BIO *bi) | |
| 153 { | |
| 154 bi->init=1; | |
| 155 bi->num=0; | |
| 156 bi->ptr=NULL; | |
| 157 xopenlog(bi, "application", LOG_DAEMON); | |
| 158 return(1); | |
| 159 } | |
| 160 | |
| 161 static int MS_CALLBACK slg_free(BIO *a) | |
| 162 { | |
| 163 if (a == NULL) return(0); | |
| 164 xcloselog(a); | |
| 165 return(1); | |
| 166 } | |
| 167 | |
| 168 static int MS_CALLBACK slg_write(BIO *b, const char *in, int inl) | |
| 169 { | |
| 170 int ret= inl; | |
| 171 char* buf; | |
| 172 char* pp; | |
| 173 int priority, i; | |
| 174 static const struct | |
| 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 }; | |
| 203 | |
| 204 if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){ | |
| 205 return(0); | |
| 206 } | |
| 207 strncpy(buf, in, inl); | |
| 208 buf[inl]= '\0'; | |
| 209 | |
| 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; | |
| 214 | |
| 215 xsyslog(b, priority, pp); | |
| 216 | |
| 217 OPENSSL_free(buf); | |
| 218 return(ret); | |
| 219 } | |
| 220 | |
| 221 static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, void *ptr) | |
| 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 | |
| 235 static int MS_CALLBACK slg_puts(BIO *bp, const char *str) | |
| 236 { | |
| 237 int n,ret; | |
| 238 | |
| 239 n=strlen(str); | |
| 240 ret=slg_write(bp,str,n); | |
| 241 return(ret); | |
| 242 } | |
| 243 | |
| 244 #if defined(OPENSSL_SYS_WIN32) | |
| 245 | |
| 246 static void xopenlog(BIO* bp, char* name, int level) | |
| 247 { | |
| 248 if (GetVersion() < 0x80000000) | |
| 249 bp->ptr = RegisterEventSourceA(NULL,name); | |
| 250 else | |
| 251 bp->ptr = NULL; | |
| 252 } | |
| 253 | |
| 254 static void xsyslog(BIO *bp, int priority, const char *string) | |
| 255 { | |
| 256 LPCSTR lpszStrings[2]; | |
| 257 WORD evtype= EVENTLOG_ERROR_TYPE; | |
| 258 char pidbuf[DECIMAL_SIZE(DWORD)+4]; | |
| 259 | |
| 260 if (bp->ptr == NULL) | |
| 261 return; | |
| 262 | |
| 263 switch (priority) | |
| 264 { | |
| 265 case LOG_EMERG: | |
| 266 case LOG_ALERT: | |
| 267 case LOG_CRIT: | |
| 268 case LOG_ERR: | |
| 269 evtype = EVENTLOG_ERROR_TYPE; | |
| 270 break; | |
| 271 case LOG_WARNING: | |
| 272 evtype = EVENTLOG_WARNING_TYPE; | |
| 273 break; | |
| 274 case LOG_NOTICE: | |
| 275 case LOG_INFO: | |
| 276 case LOG_DEBUG: | |
| 277 evtype = EVENTLOG_INFORMATION_TYPE; | |
| 278 break; | |
| 279 default: /* Should never happen, but set it | |
| 280 as error anyway. */ | |
| 281 evtype = EVENTLOG_ERROR_TYPE; | |
| 282 break; | |
| 283 } | |
| 284 | |
| 285 sprintf(pidbuf, "[%u] ", GetCurrentProcessId()); | |
| 286 lpszStrings[0] = pidbuf; | |
| 287 lpszStrings[1] = string; | |
| 288 | |
| 289 ReportEventA(bp->ptr, evtype, 0, 1024, NULL, 2, 0, | |
| 290 lpszStrings, NULL); | |
| 291 } | |
| 292 | |
| 293 static void xcloselog(BIO* bp) | |
| 294 { | |
| 295 if(bp->ptr) | |
| 296 DeregisterEventSource((HANDLE)(bp->ptr)); | |
| 297 bp->ptr= NULL; | |
| 298 } | |
| 299 | |
| 300 #elif defined(OPENSSL_SYS_VMS) | |
| 301 | |
| 302 static int VMS_OPC_target = LOG_DAEMON; | |
| 303 | |
| 304 static void xopenlog(BIO* bp, char* name, int level) | |
| 305 { | |
| 306 VMS_OPC_target = level; | |
| 307 } | |
| 308 | |
| 309 static void xsyslog(BIO *bp, int priority, const char *string) | |
| 310 { | |
| 311 struct dsc$descriptor_s opc_dsc; | |
| 312 | |
| 313 /* Arrange 32-bit pointer to opcdef buffer and malloc(), if needed. */ | |
| 314 #if __INITIAL_POINTER_SIZE == 64 | |
| 315 # pragma pointer_size save | |
| 316 # pragma pointer_size 32 | |
| 317 # define OPCDEF_TYPE __char_ptr32 | |
| 318 # define OPCDEF_MALLOC _malloc32 | |
| 319 #else /* __INITIAL_POINTER_SIZE == 64 */ | |
| 320 # define OPCDEF_TYPE char * | |
| 321 # define OPCDEF_MALLOC OPENSSL_malloc | |
| 322 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ | |
| 323 | |
| 324 struct opcdef *opcdef_p; | |
| 325 | |
| 326 #if __INITIAL_POINTER_SIZE == 64 | |
| 327 # pragma pointer_size restore | |
| 328 #endif /* __INITIAL_POINTER_SIZE == 64 */ | |
| 329 | |
| 330 char buf[10240]; | |
| 331 unsigned int len; | |
| 332 struct dsc$descriptor_s buf_dsc; | |
| 333 $DESCRIPTOR(fao_cmd, "!AZ: !AZ"); | |
| 334 char *priority_tag; | |
| 335 | |
| 336 switch (priority) | |
| 337 { | |
| 338 case LOG_EMERG: priority_tag = "Emergency"; break; | |
| 339 case LOG_ALERT: priority_tag = "Alert"; break; | |
| 340 case LOG_CRIT: priority_tag = "Critical"; break; | |
| 341 case LOG_ERR: priority_tag = "Error"; break; | |
| 342 case LOG_WARNING: priority_tag = "Warning"; break; | |
| 343 case LOG_NOTICE: priority_tag = "Notice"; break; | |
| 344 case LOG_INFO: priority_tag = "Info"; break; | |
| 345 case LOG_DEBUG: priority_tag = "DEBUG"; break; | |
| 346 } | |
| 347 | |
| 348 buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T; | |
| 349 buf_dsc.dsc$b_class = DSC$K_CLASS_S; | |
| 350 buf_dsc.dsc$a_pointer = buf; | |
| 351 buf_dsc.dsc$w_length = sizeof(buf) - 1; | |
| 352 | |
| 353 lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string); | |
| 354 | |
| 355 /* We know there's an 8-byte header. That's documented. */ | |
| 356 opcdef_p = OPCDEF_MALLOC( 8+ len); | |
| 357 opcdef_p->opc$b_ms_type = OPC$_RQ_RQST; | |
| 358 memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3); | |
| 359 opcdef_p->opc$l_ms_rqstid = 0; | |
| 360 memcpy(&opcdef_p->opc$l_ms_text, buf, len); | |
| 361 | |
| 362 opc_dsc.dsc$b_dtype = DSC$K_DTYPE_T; | |
| 363 opc_dsc.dsc$b_class = DSC$K_CLASS_S; | |
| 364 opc_dsc.dsc$a_pointer = (OPCDEF_TYPE) opcdef_p; | |
| 365 opc_dsc.dsc$w_length = len + 8; | |
| 366 | |
| 367 sys$sndopr(opc_dsc, 0); | |
| 368 | |
| 369 OPENSSL_free(opcdef_p); | |
| 370 } | |
| 371 | |
| 372 static void xcloselog(BIO* bp) | |
| 373 { | |
| 374 } | |
| 375 | |
| 376 #else /* Unix/Watt32 */ | |
| 377 | |
| 378 static void xopenlog(BIO* bp, char* name, int level) | |
| 379 { | |
| 380 #ifdef WATT32 /* djgpp/DOS */ | |
| 381 openlog(name, LOG_PID|LOG_CONS|LOG_NDELAY, level); | |
| 382 #else | |
| 383 openlog(name, LOG_PID|LOG_CONS, level); | |
| 384 #endif | |
| 385 } | |
| 386 | |
| 387 static void xsyslog(BIO *bp, int priority, const char *string) | |
| 388 { | |
| 389 syslog(priority, "%s", string); | |
| 390 } | |
| 391 | |
| 392 static void xcloselog(BIO* bp) | |
| 393 { | |
| 394 closelog(); | |
| 395 } | |
| 396 | |
| 397 #endif /* Unix */ | |
| 398 | |
| 399 #endif /* NO_SYSLOG */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2072073002:
Delete bundled copy of OpenSSL and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master