OpenSolaris_b135/common/net/wanboot/bootlog.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* bootlog() - error notification and progress reporting for
* WAN boot components
*/
#include <sys/varargs.h>
#include <sys/types.h>
#include <sys/strlog.h>
#include <sys/wanboot_impl.h>
#include <errno.h>
#include <time.h>
#include <boot_http.h>
#include <stdio.h>
#include <parseURL.h>
#include <bootlog.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <libintl.h>
#include <netboot_paths.h>
#include <wanboot_conf.h>
#include <bootinfo.h>
#ifdef _BOOT
#include <sys/bootdebug.h>
#endif
static struct code pri_names[] = {
"panic", BOOTLOG_EMERG,
"alert", BOOTLOG_ALERT,
"crit", BOOTLOG_CRIT,
"warn", BOOTLOG_WARNING,
"info", BOOTLOG_INFO,
"debug", BOOTLOG_DEBUG,
"verbose", BOOTLOG_VERBOSE,
"progress", BOOTLOG_PROGRESS,
"none", NOPRI,
NULL, -1
};
typedef enum {
BL_NO_TRANSPORT,
BL_LOCAL_FILE,
BL_CONSOLE,
BL_HTTP,
BL_HTTPS
} bl_transport_t;
typedef struct list_entry {
char message[BOOTLOG_QS_MAX];
struct list_entry *flink;
} list;
#define BOOTLOG_RING_NELEM 512
static struct ringbuffer_t {
int w_ptr;
int r_ptr;
list entries[BOOTLOG_RING_NELEM];
} ringbuffer;
static FILE *bl_filehandle = NULL;
static http_handle_t bl_httphandle = NULL;
static url_t bl_url;
static bl_transport_t bl_transport = BL_NO_TRANSPORT;
static bl_transport_t openbootlog(void);
static boolean_t setup_con(http_handle_t, boolean_t, boolean_t);
static char *url_encode(const char *);
static boolean_t sendmessage(bl_transport_t, char *, const char *,
bootlog_severity_t, int);
static int ptr_incr(int ptr);
static int ptr_decr(int ptr);
static void rb_init(struct ringbuffer_t *);
static void rb_write(struct ringbuffer_t *, const char *);
static int rb_read(struct ringbuffer_t *, char *);
/*
* Return a string representing the current time; not thread-safe.
*/
static const char *
gettime(void)
{
static char timebuf[sizeof ("Tue Jan 19 03:14:07 2038\n")];
time_t curtime;
if (time(&curtime) == 0)
return ("<time unavailable>");
(void) strlcpy(timebuf, ctime(&curtime), sizeof (timebuf));
timebuf[19] = '\0'; /* truncate before "2038" above */
return (timebuf);
}
/*
* bootlog_common() - Common routine used by bootlog() and
* bootlog_internal() to write a message comprising a message
* header and a message body to the appropriate transport.
* The message header comprises an ident string and a message
* severity.
*/
static void
bootlog_common(const char *ident, bootlog_severity_t severity, char *message)
{
bl_transport_t entry_transport;
static int blrecurs;
static int blretry;
/*
* This function may be called recursively because the HTTP code
* is a bootlog consumer. The blrecurs variable is used to determine
* whether or not the invocation is recursive.
*/
blrecurs++;
entry_transport = bl_transport;
/*
* If this is the first bootlog call then setup the transport.
* We only do this in a non-recursive invocation as openbootlog()
* results in a recursive call for a HTTP or HTTPS transport.
*/
if (bl_transport == BL_NO_TRANSPORT && blrecurs == 1) {
rb_init(&ringbuffer);
bl_transport = openbootlog();
}
/*
* If we're not there already, try to move up a level.
* This is necessary because our consumer may have begun
* logging before it had enough information to initialize
* its HTTP or HTTPS transport. We've arbitrarily decided
* that we'll only check to see if we should move up, on
* every third (blretry) non-recursive invocation.
*/
if (blrecurs == 1 &&
!(bl_transport == BL_HTTPS || bl_transport == BL_HTTP)) {
if (blretry > 3) {
bl_transport = openbootlog();
blretry = 0;
} else
blretry++;
}
if (entry_transport != bl_transport) {
switch (bl_transport) {
case BL_CONSOLE:
(void) printf(
"%s wanboot info: WAN boot messages->console\n",
gettime());
break;
case BL_HTTP:
case BL_HTTPS:
(void) printf(
"%s wanboot info: WAN boot messages->%s:%u\n",
gettime(), bl_url.hport.hostname,
bl_url.hport.port);
break;
default:
break;
}
}
/*
* Failed attempts and recursively generated log messages are
* sent to the fallback transport.
*/
if (blrecurs > 1 || !sendmessage(bl_transport, message, ident,
severity, 0)) {
/*
* Fallback to a log file if one exists, or the console
* as a last resort. Note that bl_filehandle will always
* be NULL in standalone.
*/
(void) sendmessage(bl_filehandle != NULL ? BL_LOCAL_FILE :
BL_CONSOLE, message, ident, severity, 1);
}
blrecurs--;
}
/*
* bootlog() - the exposed interface for logging boot messages.
*/
/* PRINTFLIKE3 */
void
bootlog(const char *ident, bootlog_severity_t severity, char *fmt, ...)
{
char message[BOOTLOG_MSG_MAX_LEN];
va_list adx;
va_start(adx, fmt);
(void) vsnprintf(message, BOOTLOG_MSG_MAX_LEN, fmt, adx);
va_end(adx);
bootlog_common(ident, severity, message);
}
/*
* libbootlog() - an internal interface for logging boot
* messages.
*/
/* PRINTFLIKE2 */
void
libbootlog(bootlog_severity_t severity, char *fmt, ...)
{
char message[BOOTLOG_MSG_MAX_LEN];
va_list adx;
va_start(adx, fmt);
(void) vsnprintf(message, BOOTLOG_MSG_MAX_LEN,
dgettext(TEXT_DOMAIN, fmt), adx);
va_end(adx);
bootlog_common("libwanboot", severity, message);
}
static boolean_t
send_http(void)
{
http_respinfo_t *resp = NULL;
char buffer[BOOTLOG_MAX_URL + (BOOTLOG_QS_MAX * 3)];
char ringmessage[BOOTLOG_QS_MAX];
char *lenstr;
size_t length;
int retries;
while ((rb_read(&ringbuffer, ringmessage) != -1)) {
(void) snprintf(buffer, sizeof (buffer), "%s?%s",
bl_url.abspath, url_encode(ringmessage));
for (retries = 0; retries < BOOTLOG_CONN_RETRIES; retries++) {
if (retries > 0) {
(void) http_srv_disconnect(bl_httphandle);
if (http_srv_connect(bl_httphandle) != 0)
continue;
}
if (http_get_request(bl_httphandle, buffer) != 0 ||
http_process_headers(bl_httphandle, &resp) != 0)
continue;
if (resp->code != 200) {
http_free_respinfo(resp);
continue;
}
http_free_respinfo(resp);
lenstr = http_get_header_value(bl_httphandle,
"Content-Length");
length = strtol(lenstr, NULL, 10);
if (http_read_body(bl_httphandle, buffer, length) > 0)
break;
}
/*
* The attempt to log the message failed. Back the
* read pointer up so that we'll try to log it again
* later.
*/
if (retries == BOOTLOG_CONN_RETRIES) {
ringbuffer.r_ptr = ptr_decr(ringbuffer.r_ptr);
return (B_FALSE);
}
}
return (B_TRUE);
}
static boolean_t
sendmessage(bl_transport_t transport, char *message, const char *ident,
bootlog_severity_t severity, int failure)
{
static char *progtype = NULL;
char ringmessage[BOOTLOG_QS_MAX];
char hostname[MAXHOSTNAMELEN];
uint32_t msgid;
boolean_t ret;
int i;
/*
* In standalone, only log VERBOSE and DEBUG messages if the
* corresponding flag (-V or -d) has been passed to boot.
*
* Note that some bootlog() consumers impose additional constraints on
* printing these messages -- for instance, http_set_verbose() must be
* used before the HTTP code will call bootlog() with BOOTLOG_VERBOSE
* messages.
*/
#ifdef _BOOT
if (severity == BOOTLOG_DEBUG && !(boothowto & RB_DEBUG))
return (B_TRUE);
if (severity == BOOTLOG_VERBOSE && !verbosemode)
return (B_TRUE);
#endif
for (i = 0; pri_names[i].c_val != NOPRI; i++) {
if (severity == pri_names[i].c_val)
break;
}
/*
* VERBOSE and DEBUG messages always go to the console
*/
if (transport != BL_CONSOLE &&
(severity == BOOTLOG_DEBUG || severity == BOOTLOG_VERBOSE)) {
(void) printf("%s %s %s: %s\n", gettime(), ident,
pri_names[i].c_name, message);
}
STRLOG_MAKE_MSGID(message, msgid);
(void) gethostname(hostname, sizeof (hostname));
/*
* Note that in this case, "<time>" is a placeholder that will be used
* to fill in the actual time on the remote end.
*/
(void) snprintf(ringmessage, sizeof (ringmessage),
"<time> %s %s: [ID %u user.%s] %s", hostname, ident, msgid,
pri_names[i].c_name, message);
/*
* Prevent duplicate messages from being inserted into
* the ring buffer.
*/
if (failure == 0) {
rb_write(&ringbuffer, ringmessage);
}
switch (transport) {
case BL_CONSOLE:
/*
* PROGRESS messages update in-place on the console, as long
* as they are of the same 'progress type' (see below) --
* if not, reset the progress information.
*/
if (progtype != NULL && (severity != BOOTLOG_PROGRESS ||
strncmp(progtype, message, strlen(progtype)) != 0)) {
(void) printf("\n");
free(progtype);
progtype = NULL;
}
(void) printf("%s %s %s: %s\r", gettime(), ident,
pri_names[i].c_name, message);
if (severity != BOOTLOG_PROGRESS) {
(void) printf("\n");
} else if (progtype == NULL) {
/*
* New progress message; save its "type" (the part
* of the message up to and including the first
* colon). This should be made less clumsy in the
* future.
*/
progtype = strdup(message);
if (progtype != NULL) {
for (i = 0; progtype[i] != '\0'; i++) {
if (progtype[i] == ':') {
progtype[++i] = '\0';
break;
}
}
}
}
ret = B_TRUE;
break;
case BL_LOCAL_FILE:
if (bl_filehandle == NULL)
return (B_FALSE);
(void) fprintf(bl_filehandle, "%s %s %s: [ID %u user.%s] %s\n",
gettime(), hostname, ident, msgid, pri_names[i].c_name,
message);
ret = B_TRUE;
break;
case BL_HTTP:
case BL_HTTPS:
if (bl_httphandle == NULL)
return (B_FALSE);
ret = send_http();
break;
case BL_NO_TRANSPORT:
default:
ret = B_FALSE;
}
return (ret);
}
static bl_transport_t
openbootlog(void)
{
static boolean_t got_boot_logger = B_FALSE;
static boolean_t bl_url_valid = B_FALSE;
static boolean_t clientauth = B_FALSE;
static bc_handle_t bootconf_handle;
bl_transport_t transport;
/*
* We try to use a logfile in userland since our consumer (install)
* needs complete control over the terminal.
*/
#ifndef _BOOT
if (bl_filehandle == NULL)
bl_filehandle = fopen("/var/log/bootlog", "a");
#endif
transport = (bl_filehandle != NULL) ? BL_LOCAL_FILE : BL_CONSOLE;
/*
* If we haven't already been able to access wanboot.conf for a
* boot_logger URL, see if we can now.
*/
if (!got_boot_logger &&
bootconf_init(&bootconf_handle, NULL) == BC_SUCCESS) {
char *urlstr;
char *cas;
/*
* If there is a boot_logger, ensure that it's is a legal URL.
*/
if ((urlstr = bootconf_get(&bootconf_handle,
BC_BOOT_LOGGER)) != NULL &&
url_parse(urlstr, &bl_url) == URL_PARSE_SUCCESS) {
bl_url_valid = B_TRUE;
}
/*
* If the boot_logger URL uses an HTTPS scheme, see if
* client authentication is specified.
*/
if (bl_url.https) {
cas = bootconf_get(&bootconf_handle,
BC_CLIENT_AUTHENTICATION);
if (cas != NULL) {
clientauth = (strcmp(cas, BC_YES) == 0);
}
}
bootconf_end(&bootconf_handle);
/*
* Having now accessed wanboot.conf, remember not to come
* this way again; the value of boot_logger cannot change.
*/
got_boot_logger = B_TRUE;
}
/*
* If there is no legal boot_logger URL available, then we're done.
*/
if (!bl_url_valid) {
return (transport);
}
/*
* If we don't already have a bl_httphandle, try to get one.
* If we fail, then we're done.
*/
if (bl_httphandle == NULL) {
bl_httphandle = http_srv_init(&bl_url);
if (bl_httphandle == NULL) {
return (transport);
}
}
/*
* If we succeed in setting up the connection,
* then we use the connection as our transport.
* Otherwise, we use the transport we've already
* determined above.
*/
if (setup_con(bl_httphandle, bl_url.https, clientauth)) {
transport = bl_url.https ? BL_HTTPS : BL_HTTP;
}
return (transport);
}
static boolean_t
setup_con(http_handle_t handle, boolean_t https, boolean_t client_auth)
{
static boolean_t got_proxy = B_FALSE;
static boolean_t proxy_valid = B_FALSE;
static url_hport_t proxy;
int i;
/*
* If an HTTPS scheme is specified, then check that time
* has been initialized.
* If time() returns a non-zero value, then we know
* that the boot file system has been mounted and that
* we have a trusted time.
*/
if (https && time(0) == 0)
return (B_FALSE);
if (!got_proxy && bootinfo_init()) {
char hpstr[URL_MAX_STRLEN];
size_t vallen = sizeof (hpstr);
/*
* If there is a http-proxy, ensure that it's a legal host:port.
*/
if (bootinfo_get(BI_HTTP_PROXY, hpstr, &vallen, NULL) ==
BI_E_SUCCESS && vallen > 0) {
hpstr[vallen] = '\0';
if (url_parse_hostport(hpstr, &proxy,
URL_DFLT_PROXY_PORT) == URL_PARSE_SUCCESS) {
proxy_valid = B_TRUE;
}
}
got_proxy = B_TRUE;
}
if (proxy_valid && http_set_proxy(handle, &proxy) != 0)
return (B_FALSE);
(void) http_set_keepalive(handle, 1);
(void) http_set_socket_read_timeout(handle, BOOTLOG_HTTP_TIMEOUT);
/*
* If an HTTPS scheme is specified, then setup the necessary
* SSL context for the connection
*/
if (https) {
if (http_set_random_file(handle, "/dev/urandom") == -1)
return (B_FALSE);
if (http_set_certificate_authority_file(NB_CA_CERT_PATH) < 0)
return (B_FALSE);
/*
* The client certificate and key will not exist unless
* client authentication has been configured. If it is
* configured then the webserver will have added these
* files to the wanboot file system and the HTTP library
* needs to be made aware of their existence.
*/
if (client_auth) {
if (http_set_client_certificate_file(handle,
NB_CLIENT_CERT_PATH) < 0) {
return (B_FALSE);
}
if (http_set_private_key_file(handle,
NB_CLIENT_KEY_PATH) < 0) {
return (B_FALSE);
}
}
if (http_set_password(handle, WANBOOT_PASSPHRASE) < 0)
return (B_FALSE);
}
for (i = 0; i < BOOTLOG_CONN_RETRIES; i++) {
if (http_srv_connect(handle) == 0)
return (B_TRUE);
(void) http_srv_disconnect(handle);
}
return (B_FALSE);
}
static char *
url_encode(const char *ibufp)
{
int i;
char c;
unsigned char nibble;
static char obuff[BOOTLOG_QS_MAX * 3];
char *obufp = obuff;
/*
* Encode special characters as outlined in RFC2396.
*
* Special characters are encoded as a triplets beginning
* with '%' followed by the two hexidecimal digits representing
* the octet code. The space character is special. It can be encoded
* simply as a '+'.
*/
while ((c = *ibufp++) != '\0') {
/*
* Is the character one of the special characters
* that require encoding? If so append '%' to the output
* buffer follow that by the hexascii value.
*/
if (strchr("/?{}|^~[]`<>#%=\"\t", c) != NULL) {
*obufp++ = '%';
/*
* Compute the character's hex value and
* convert it to ASCII. That is two nibbles
* per character.
*/
for (i = 1; i >= 0; i--) {
nibble = ((uchar_t)c >> (4 * i)) & 0x0f;
/*
* If the hex digit is 0xa - 0xf, then
* compute its ASCII value by adding 0x37
* else 0x0 - 0x9 just add 0x30.
*/
if (nibble > 0x9)
nibble += 0x37;
else
nibble += 0x30;
*obufp++ = nibble;
}
/*
* The space character gets a special mapping.
*/
} else if (c == ' ') {
*obufp++ = '+';
/*
* Append the rest (sans any CR character)
*/
} else if (c != '\n') {
*obufp++ = c;
}
}
*obufp = '\0';
return (obuff);
}
static void
rb_init(struct ringbuffer_t *buffer)
{
int i;
buffer->w_ptr = 0;
buffer->r_ptr = 0;
for (i = 0; i < BOOTLOG_RING_NELEM; i++)
buffer->entries[i].message[0] = '\0';
}
static int
ptr_incr(int ptr)
{
if (++ptr < BOOTLOG_RING_NELEM)
return (ptr);
else
return (0);
}
static int
ptr_decr(int ptr)
{
if (ptr == 0)
return (BOOTLOG_RING_NELEM - 1);
else
return (--ptr);
}
static void
rb_write(struct ringbuffer_t *buffer, const char *buff)
{
(void) strlcpy(buffer->entries[buffer->w_ptr].message, buff,
BOOTLOG_QS_MAX);
buffer->w_ptr = ptr_incr(buffer->w_ptr);
if (buffer->r_ptr == buffer->w_ptr)
buffer->r_ptr = ptr_incr(buffer->r_ptr);
}
static int
rb_read(struct ringbuffer_t *buffer, char *buff)
{
if (buffer->r_ptr != buffer->w_ptr) {
(void) strlcpy(buff, buffer->entries[buffer->r_ptr].message,
BOOTLOG_QS_MAX);
buffer->r_ptr = ptr_incr(buffer->r_ptr);
return (0);
}
return (-1);
}