libipmi/common/ipmi_lan.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <unistd.h>
#include <netdb.h>
#include <fcntl.h>

#include "libipmi.h"
#include "ipmi_lan.h"
#include "ipmi_impl.h"

#define DEF_IPMI_LAN_TIMEOUT        3 /* seconds */
#define DEF_IPMI_LAN_NUM_RETRIES    5
#define IPMI_LAN_CHANNEL_E      0x0e

typedef struct ipmi_rs {
    uint8_t     ir_data[IPMI_BUF_SIZE];
    int     ir_dlen;
    ipmi_msg_hdr_t  ir_ihdr;
    uint8_t     ir_ccode;
} ipmi_rs_t;

static ipmi_rs_t *ipmi_lan_poll_recv(ipmi_handle_t *);

typedef struct ipmi_rq_entry {
    ipmi_list_t ire_list;
    ipmi_cmd_t  ire_req;
    uint8_t     ire_target_cmd;
    uint8_t     ire_rq_seq;
    uint8_t     *ire_msg_data;
    int     ire_msg_len;
} ipmi_rq_entry_t;

ipmi_rq_entry_t *ipmi_req_entries = NULL;

/*
 * LAN transport-specific data
 */
typedef struct ipmi_lan {
    ipmi_handle_t   *il_ihp;
    char        il_host[MAXHOSTNAMELEN + 1];
    uint16_t    il_port;
    char        il_user[17];
    char        il_authcode[IPMI_AUTHCODE_BUF_SIZE + 1];
    uint8_t     il_challenge[16];
    uint32_t    il_session_id;
    int         il_sd;
    boolean_t   il_send_authcode;
    boolean_t   il_session_active;
    uint8_t     il_authtype;
    uint8_t     il_privlvl;
    uint8_t     il_num_retries;
    uint32_t    il_in_seq;
    uint32_t    il_timeout;
    struct sockaddr_in il_addr;
    socklen_t   il_addrlen;
} ipmi_lan_t;

/*
 * Calculate and returns IPMI checksum
 *
 * Checksum algorithm is described in Section 13.8
 *
 * d:       buffer to check
 * s:       position in buffer to start checksum from
 */
static uint8_t
ipmi_csum(uint8_t *d, int s)
{
    uint8_t c = 0;
    for (; s > 0; s--, d++)
        c += *d;
    return (-c);
}

static ipmi_rq_entry_t *
ipmi_req_add_entry(ipmi_handle_t *ihp, ipmi_cmd_t *req)
{
    ipmi_rq_entry_t *e;

    if ((e = ipmi_zalloc(ihp, sizeof (ipmi_rq_entry_t))) == NULL)
        return (NULL);

    (void) memcpy(&e->ire_req, req, sizeof (ipmi_cmd_t));
    ipmi_list_append(&ipmi_req_entries->ire_list, e);

    return (e);
}

/*ARGSUSED*/
static ipmi_rq_entry_t *
ipmi_req_lookup_entry(ipmi_handle_t *ihp, uint8_t seq, uint8_t cmd)
{
    ipmi_rq_entry_t *e;

    for (e = ipmi_list_next(&ipmi_req_entries->ire_list); e != NULL;
        e = ipmi_list_next(e))
        if (e->ire_rq_seq == seq && e->ire_req.ic_cmd == cmd)
            return (e);

    return (NULL);
}

static void
ipmi_req_remove_entry(ipmi_handle_t *ihp, uint8_t seq, uint8_t cmd)
{
    ipmi_rq_entry_t *e;

    e = ipmi_req_lookup_entry(ihp, seq, cmd);

    if (e) {
        ipmi_list_delete(&ipmi_req_entries->ire_list, e);
        ipmi_free(ihp, e->ire_msg_data);
        ipmi_free(ihp, e);
    }
}

static void
ipmi_req_clear_entries(ipmi_handle_t *ihp)
{
    ipmi_rq_entry_t *e;

    while ((e = ipmi_list_next(&ipmi_req_entries->ire_list)) != NULL) {
        ipmi_list_delete(&ipmi_req_entries->ire_list, e);
        ipmi_free(ihp, e);
    }
}

static int
get_random(void *buf, uint_t len)
{
    int fd;

    assert(buf != NULL && len > 0);
    if ((fd = open("/dev/urandom", O_RDONLY)) < 0)
        return (-1);

    if (read(fd, buf, len) < 0) {
        (void) close(fd);
        return (-1);
    }
    (void) close(fd);
    return (0);
}

static int
ipmi_lan_send_packet(ipmi_handle_t *ihp, uint8_t *data, int dlen)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;

    return (send(ilp->il_sd, data, dlen, 0));
}

static ipmi_rs_t *
ipmi_lan_recv_packet(ipmi_handle_t *ihp)
{
    static ipmi_rs_t rsp;
    fd_set read_set, err_set;
    struct timeval tmout;
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    int ret;

    FD_ZERO(&read_set);
    FD_SET(ilp->il_sd, &read_set);

    FD_ZERO(&err_set);
    FD_SET(ilp->il_sd, &err_set);

    tmout.tv_sec =  ilp->il_timeout;
    tmout.tv_usec = 0;

    ret = select(ilp->il_sd + 1, &read_set, NULL, &err_set, &tmout);
    if (ret < 0 || FD_ISSET(ilp->il_sd, &err_set) ||
        !FD_ISSET(ilp->il_sd, &read_set))
        return (NULL);

    /*
     * The first read may return ECONNREFUSED because the rmcp ping
     * packet--sent to UDP port 623--will be processed by both the
     * BMC and the OS.
     *
     * The problem with this is that the ECONNREFUSED takes
     * priority over any other received datagram; that means that
     * the Connection Refused shows up _before_ the response packet,
     * regardless of the order they were sent out.  (unless the
     * response is read before the connection refused is returned)
     */
    ret = recv(ilp->il_sd, &rsp.ir_data, IPMI_BUF_SIZE, 0);

    if (ret < 0) {
        FD_ZERO(&read_set);
        FD_SET(ilp->il_sd, &read_set);

        FD_ZERO(&err_set);
        FD_SET(ilp->il_sd, &err_set);

        tmout.tv_sec = ilp->il_timeout;
        tmout.tv_usec = 0;

        ret = select(ilp->il_sd + 1, &read_set, NULL, &err_set, &tmout);
        if (ret < 0) {
            if (FD_ISSET(ilp->il_sd, &err_set) ||
                !FD_ISSET(ilp->il_sd, &read_set))
                return (NULL);

            ret = recv(ilp->il_sd, &rsp.ir_data, IPMI_BUF_SIZE, 0);
            if (ret < 0)
                return (NULL);
        }
    }

    if (ret == 0)
        return (NULL);

    rsp.ir_data[ret] = '\0';
    rsp.ir_dlen = ret;

    return (&rsp);
}


/*
 * ASF/RMCP Pong Message
 *
 * See section 13.2.4
 */
struct rmcp_pong {
    rmcp_hdr_t rp_rmcp;
    asf_hdr_t rp_asf;
    uint32_t rp_iana;
    uint32_t rp_oem;
    uint8_t rp_sup_entities;
    uint8_t rp_sup_interact;
    uint8_t rp_reserved[6];
};

/*
 * parse response RMCP "pong" packet
 *
 * return -1 if ping response not received
 * returns 0 if IPMI is NOT supported
 * returns 1 if IPMI is supported
 */
/*ARGSUSED*/
static int
ipmi_handle_pong(ipmi_handle_t *ihp, ipmi_rs_t *rsp)
{
    struct rmcp_pong *pong;

    if (rsp == NULL)
        return (-1);

    /*LINTED: E_BAD_PTR_CAST_ALIGN*/
    pong = (struct rmcp_pong *)rsp->ir_data;

    return ((pong->rp_sup_entities & 0x80) ? 1 : 0);
}

/*
 * Build and send RMCP presence ping message
 */
static int
ipmi_lan_ping(ipmi_handle_t *ihp)
{
    rmcp_hdr_t rmcp_ping;
    asf_hdr_t asf_ping;
    uint8_t *data;
    int rv, dlen = sizeof (rmcp_ping) + sizeof (asf_ping);

    (void) memset(&rmcp_ping, 0, sizeof (rmcp_ping));
    rmcp_ping.rh_version = RMCP_VERSION_1;
    rmcp_ping.rh_msg_class = RMCP_CLASS_ASF;
    rmcp_ping.rh_seq = 0xff;

    (void) memset(&asf_ping, 0, sizeof (asf_ping));
    asf_ping.ah_iana = htonl(ASF_RMCP_IANA);
    asf_ping.ah_msg_type = ASF_TYPE_PING;

    if ((data = ipmi_zalloc(ihp, dlen)) == NULL)
        return (-1);

    (void) memcpy(data, &rmcp_ping, sizeof (rmcp_ping));
    (void) memcpy(data + sizeof (rmcp_ping), &asf_ping, sizeof (asf_ping));

    rv = ipmi_lan_send_packet(ihp, data, dlen);

    ipmi_free(ihp, data);

    if (rv < 0)
        return (ipmi_set_error(ihp, EIPMI_LAN_PING_FAILED, NULL));

    if (ipmi_lan_poll_recv(ihp) == NULL)
        return (ipmi_set_error(ihp, EIPMI_LAN_PING_FAILED, NULL));

    return (0);
}

static ipmi_rs_t *
ipmi_lan_poll_recv(ipmi_handle_t *ihp)
{
    rmcp_hdr_t rmcp_rsp;
    ipmi_rs_t *rsp;
    ipmi_rq_entry_t *entry;
    int off = 0, rv;
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    uint8_t rsp_authtype;

    rsp = ipmi_lan_recv_packet(ihp);

    while (rsp != NULL) {

        /* parse response headers */
        (void) memcpy(&rmcp_rsp, rsp->ir_data, 4);

        switch (rmcp_rsp.rh_msg_class) {
        case RMCP_CLASS_ASF:
            /* ping response packet */
            rv = ipmi_handle_pong(ihp, rsp);
            return ((rv <= 0) ? NULL : rsp);
        case RMCP_CLASS_IPMI:
            /* handled by rest of function */
            break;
        default:
            /* Invalid RMCP class */
            rsp = ipmi_lan_recv_packet(ihp);
            continue;
        }

        off = sizeof (rmcp_hdr_t);
        rsp_authtype = rsp->ir_data[off];
        if (ilp->il_send_authcode && (rsp_authtype || ilp->il_authtype))
            off += 26;
        else
            off += 10;

        (void) memcpy(&rsp->ir_ihdr, (void *)(rsp->ir_data + off),
            sizeof (rsp->ir_ihdr));
        rsp->ir_ihdr.imh_seq = rsp->ir_ihdr.imh_seq >> 2;
        off += sizeof (rsp->ir_ihdr);
        rsp->ir_ccode = rsp->ir_data[off++];

        entry = ipmi_req_lookup_entry(ihp, rsp->ir_ihdr.imh_seq,
            rsp->ir_ihdr.imh_cmd);
        if (entry) {
            ipmi_req_remove_entry(ihp, rsp->ir_ihdr.imh_seq,
                rsp->ir_ihdr.imh_cmd);
        } else {
            rsp = ipmi_lan_recv_packet(ihp);
            continue;
        }
        break;
    }

    /* shift response data to start of array */
    if (rsp && rsp->ir_dlen > off) {
        rsp->ir_dlen -= off + 1;
        (void) memmove(rsp->ir_data, rsp->ir_data + off, rsp->ir_dlen);
        (void) memset(rsp->ir_data + rsp->ir_dlen, 0,
            IPMI_BUF_SIZE - rsp->ir_dlen);
    }
    return (rsp);
}

/*
 * IPMI LAN Request Message Format
 *
 * See section 13.8
 *
 * +---------------------+
 * |  rmcp_hdr_t         | 4 bytes
 * +---------------------+
 * |  v15_session_hdr_t  | 9 bytes
 * +---------------------+
 * | [authcode]          | 16 bytes (if AUTHTYPE != none)
 * +---------------------+
 * |  msg length         | 1 byte
 * +---------------------+
 * |  ipmi_msg_hdr_t     | 6 bytes
 * +---------------------+
 * | [msg data]          | variable
 * +---------------------+
 * |  msg data checksum  | 1 byte
 * +---------------------+
 */
static ipmi_rq_entry_t *
ipmi_lan_build_cmd(ipmi_handle_t *ihp, ipmi_cmd_t *req)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    rmcp_hdr_t rmcp_hdr;
    v15_session_hdr_t session_hdr;
    ipmi_msg_hdr_t msg_hdr;
    uint8_t *msg;
    int cs, tmp, off = 0, len;
    ipmi_rq_entry_t *entry;
    static int curr_seq = 0;

    if (curr_seq >= 64)
        curr_seq = 0;

    if ((entry = ipmi_req_add_entry(ihp, req)) == NULL)
        return (NULL);

    len = req->ic_dlen + 29;
    if (ilp->il_send_authcode && ilp->il_authtype)
        len += 16;

    if ((msg = ipmi_zalloc(ihp, len)) == NULL)
        /* ipmi_errno set */
        return (NULL);

    /* RMCP header */
    (void) memset(&rmcp_hdr, 0, sizeof (rmcp_hdr));
    rmcp_hdr.rh_version = RMCP_VERSION_1;
    rmcp_hdr.rh_msg_class = RMCP_CLASS_IPMI;
    rmcp_hdr.rh_seq = 0xff;
    (void) memcpy(msg, &rmcp_hdr, sizeof (rmcp_hdr));
    off = sizeof (rmcp_hdr);

    /* IPMI session header */
    (void) memset(&session_hdr, 0, sizeof (session_hdr));
    if (! ilp->il_send_authcode)
        session_hdr.sh_authtype = 0x00;
    else
        /* hardcode passwd authentication */
        session_hdr.sh_authtype = 0x04;

    (void) memcpy(&session_hdr.sh_seq, &ilp->il_in_seq, sizeof (uint32_t));
    (void) memcpy(&session_hdr.sh_id, &ilp->il_session_id,
        sizeof (uint32_t));

    (void) memcpy(msg + off, &session_hdr, sizeof (session_hdr));
    off += sizeof (session_hdr);

    /* IPMI session authcode */
    if (ilp->il_send_authcode && ilp->il_authtype) {
        (void) memcpy(msg + off, ilp->il_authcode, 16);
        off += 16;
    }

    /* message length */
    msg[off++] = req->ic_dlen + 7;
    cs = off;

    /* IPMI message header */
    (void) memset(&msg_hdr, 0, sizeof (msg_hdr));
    msg_hdr.imh_addr1 = IPMI_BMC_SLAVE_ADDR;
    msg_hdr.imh_lun = req->ic_lun;
    msg_hdr.imh_netfn = req->ic_netfn;
    tmp = off - cs;
    msg_hdr.imh_csum = ipmi_csum(msg + cs, tmp);
    cs = off;
    msg_hdr.imh_addr2 = IPMI_BMC_SLAVE_ADDR;
    entry->ire_rq_seq = curr_seq++;
    msg_hdr.imh_seq = entry->ire_rq_seq << 2;
    msg_hdr.imh_cmd = req->ic_cmd;
    (void) memcpy(msg + off, &msg_hdr, sizeof (msg_hdr));
    off += sizeof (msg_hdr);

    /* message data */
    if (req->ic_dlen != 0) {
        (void) memcpy(msg + off, req->ic_data, req->ic_dlen);
        off += req->ic_dlen;
    }

    /* message data checksum */
    tmp = off - cs;
    msg[off++] = ipmi_csum(msg + cs, tmp);

    if (ilp->il_in_seq) {
        ilp->il_in_seq++;
        if (ilp->il_in_seq == 0)
            ilp->il_in_seq++;
    }

    entry->ire_msg_len = off;
    entry->ire_msg_data = msg;

    return (entry);
}

static int
ipmi_lan_send(void *data, ipmi_cmd_t *cmd, ipmi_cmd_t *response,
    int *completion)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)data;
    ipmi_rq_entry_t *entry = NULL;
    ipmi_rs_t *rsp = NULL;
    uint_t try = 0;

    for (;;) {
        if ((entry = ipmi_lan_build_cmd(ilp->il_ihp, cmd)) == NULL)
            return (-1);

        if (ipmi_lan_send_packet(ilp->il_ihp, entry->ire_msg_data,
            entry->ire_msg_len) < 0) {
            if (++try >= ilp->il_num_retries)
                return (-1);
            (void) usleep(5000);
            continue;
        }

        (void) usleep(100);

        if ((rsp = ipmi_lan_poll_recv(ilp->il_ihp)) != NULL)
            break;

        (void) usleep(5000);
        ipmi_req_remove_entry(ilp->il_ihp, entry->ire_rq_seq,
            entry->ire_req.ic_cmd);

        if (++try >= ilp->il_num_retries)
            return (-1);
    }
    response->ic_netfn = rsp->ir_ihdr.imh_netfn;
    response->ic_lun = rsp->ir_ihdr.imh_lun;
    response->ic_cmd = rsp->ir_ihdr.imh_cmd;
    if (rsp->ir_ccode != 0) {
        *completion = rsp->ir_ccode;
        response->ic_dlen = 0;
        response->ic_data = NULL;
    } else {
        *completion = 0;
        response->ic_dlen = rsp->ir_dlen;
        response->ic_data = rsp->ir_data;
    }
    return (0);
}

/*
 * IPMI Get Session Challenge Command
 *
 * Copies the returned session ID and 16-byte challenge string to the supplied
 * buffers
 *
 * See section 22.16
 */
static int
ipmi_get_session_challenge_cmd(ipmi_handle_t *ihp, uint32_t *session_id,
    uint8_t *challenge)
{
    ipmi_cmd_t cmd, resp;
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    char msg_data[17];
    int ccode;

    (void) memset(msg_data, 0, 17);

    switch (ilp->il_authtype) {
    case IPMI_SESSION_AUTHTYPE_NONE:
        msg_data[0] = 0x00;
        break;
    case IPMI_SESSION_AUTHTYPE_MD2:
        msg_data[0] = 0x01;
        break;
    case IPMI_SESSION_AUTHTYPE_MD5:
        msg_data[0] = 0x02;
        break;
    case IPMI_SESSION_AUTHTYPE_PASSWORD:
        msg_data[0] = 0x04;
        break;
    case IPMI_SESSION_AUTHTYPE_OEM:
        msg_data[0] = 0x05;
        break;
    }
    (void) memcpy(msg_data + 1, ilp->il_user, 16);

    cmd.ic_netfn = IPMI_NETFN_APP;
    cmd.ic_lun = 0;
    cmd.ic_cmd = IPMI_CMD_GET_SESSION_CHALLENGE;
    cmd.ic_data = msg_data;
    cmd.ic_dlen = 17;

    if (ipmi_lan_send(ilp, &cmd, &resp, &ccode) != 0 || ccode)
        return (ipmi_set_error(ihp, EIPMI_LAN_CHALLENGE, NULL));

    (void) memcpy(session_id, resp.ic_data, 4);
    (void) memcpy(challenge, (uint8_t *)resp.ic_data + 4, 16);

    return (0);
}

/*
 * IPMI Activate Session Command
 *
 * See section 22.17
 */
static int
ipmi_activate_session_cmd(ipmi_handle_t *ihp)
{
    ipmi_cmd_t cmd, resp;
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    uint8_t msg_data[22], *resp_data;
    int ccode;

    cmd.ic_netfn = IPMI_NETFN_APP;
    cmd.ic_lun = 0;
    cmd.ic_cmd = IPMI_CMD_ACTIVATE_SESSION;

    switch (ilp->il_authtype) {
    case IPMI_SESSION_AUTHTYPE_NONE:
        msg_data[0] = 0x00;
        break;
    case IPMI_SESSION_AUTHTYPE_MD2:
        msg_data[0] = 0x01;
        break;
    case IPMI_SESSION_AUTHTYPE_MD5:
        msg_data[0] = 0x02;
        break;
    case IPMI_SESSION_AUTHTYPE_PASSWORD:
        msg_data[0] = 0x04;
        break;
    case IPMI_SESSION_AUTHTYPE_OEM:
        msg_data[0] = 0x05;
        break;
    }
    msg_data[1] = ilp->il_privlvl;

    (void) memcpy(msg_data + 2, ilp->il_challenge, 16);

    /* setup initial outbound sequence number */
    (void) get_random(msg_data + 18, 4);

    cmd.ic_data = msg_data;
    cmd.ic_dlen = 22;

    ilp->il_send_authcode = B_TRUE;

    if (ipmi_lan_send(ilp, &cmd, &resp, &ccode) != 0 || ccode) {
        ilp->il_send_authcode = B_FALSE;
        return (ipmi_set_error(ihp, EIPMI_LAN_SESSION, NULL));
    }

    resp_data = (uint8_t *)resp.ic_data;
    (void) memcpy(&ilp->il_session_id, resp_data + 1, 4);
    ilp->il_in_seq = resp_data[8] << 24 | resp_data[7] << 16 |
        resp_data[6] << 8 | resp_data[5];
    if (ilp->il_in_seq == 0)
        ++ilp->il_in_seq;

    return (0);
}


/*
 * See section 22.18
 *
 * returns privilege level or -1 on error
 */
static int
ipmi_set_session_privlvl_cmd(ipmi_handle_t *ihp, uint8_t privlvl)
{
    ipmi_cmd_t cmd, resp;
    int ret = 0, ccode;

    if (privlvl > IPMI_SESSION_PRIV_OEM)
        return (ipmi_set_error(ihp, EIPMI_BADPARAM, NULL));

    cmd.ic_netfn    = IPMI_NETFN_APP;
    cmd.ic_lun  = 0;
    cmd.ic_cmd  = IPMI_CMD_SET_SESSION_PRIVLVL;
    cmd.ic_data = &privlvl;
    cmd.ic_dlen = 1;

    if (ipmi_lan_send(ihp->ih_tdata, &cmd, &resp, &ccode) != 0)
        ret = ipmi_set_error(ihp, EIPMI_LAN_SETPRIV, NULL);

    return (ret);
}

/*
 * See section 22.19
 */
static int
ipmi_close_session_cmd(ipmi_handle_t *ihp)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    ipmi_cmd_t cmd, resp;
    uint8_t msg_data[4];
    int ret = 0, ccode;

    if (! ilp->il_session_active)
        return (-1);

    (void) memcpy(&msg_data, &ilp->il_session_id, 4);

    cmd.ic_netfn    = IPMI_NETFN_APP;
    cmd.ic_lun  = 0;
    cmd.ic_cmd  = IPMI_CMD_CLOSE_SESSION;
    cmd.ic_data = msg_data;
    cmd.ic_dlen = 4;

    if (ipmi_lan_send(ilp, &cmd, &resp, &ccode) != 0)
        ret = -1;

    return (ret);
}

/*
 * IPMI LAN Session Activation
 *
 * See section 13.14
 *
 * 1. send "RMCP Presence Ping" message, response message will
 *    indicate whether the platform supports IPMI
 * 2. send "Get Channel Authentication Capabilities" command
 *    with AUTHTYPE = none, response packet will contain information
 *    about supported challenge/response authentication types
 * 3. send "Get Session Challenge" command with AUTHTYPE = none
 *    and indicate the authentication type in the message, response
 *    packet will contain challenge string and temporary session ID.
 * 4. send "Activate Session" command, authenticated with AUTHTYPE
 *    sent in previous message.  Also sends the initial value for
 *    the outbound sequence number for BMC.
 * 5. BMC returns response confirming session activation and
 *    session ID for this session and initial inbound sequence.
 */
static int
ipmi_lan_activate_session(ipmi_handle_t *ihp)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)ihp->ih_tdata;
    ipmi_channel_auth_caps_t *ac;

    if (ipmi_lan_ping(ihp) != 0)
        return (-1);

    if ((ac = ipmi_get_channel_auth_caps(ihp, IPMI_LAN_CHANNEL_E,
        ilp->il_privlvl)) == NULL)
        return (-1);

    /*
     * For the sake of simplicity, we're just supporting basic password
     * authentication.  If this authentication type is not supported then
     * we'll bail here.
     */
    if (!(ac->cap_authtype & IPMI_SESSION_AUTHTYPE_PASSWORD)) {
        free(ac);
        return (ipmi_set_error(ihp, EIPMI_LAN_PASSWD_NOTSUP, NULL));
    }
    free(ac);

    if (ipmi_get_session_challenge_cmd(ihp, &ilp->il_session_id,
        ilp->il_challenge) != 0)
        return (-1);

    if (ipmi_activate_session_cmd(ihp) != 0)
        return (-1);

    ilp->il_session_active = B_TRUE;

    if (ipmi_set_session_privlvl_cmd(ihp, ilp->il_privlvl) != 0)
        return (-1);

    return (0);
}

static void
ipmi_lan_close(void *data)
{
    ipmi_lan_t *ilp = (ipmi_lan_t *)data;

    if (ilp->il_session_active)
        (void) ipmi_close_session_cmd(ilp->il_ihp);

    if (ilp->il_sd >= 0)
        (void) close(ilp->il_sd);

    ipmi_req_clear_entries(ilp->il_ihp);
    ipmi_free(ilp->il_ihp, ipmi_req_entries);
    ipmi_free(ilp->il_ihp, ilp);
}

static void *
ipmi_lan_open(ipmi_handle_t *ihp, nvlist_t *params)
{
    int rc;
    struct hostent *host;
    ipmi_lan_t *ilp;
    char *hostname, *user, *authcode;

    if ((ilp = ipmi_zalloc(ihp, sizeof (ipmi_lan_t))) == NULL) {
        /* ipmi errno set */
        return (NULL);
    }
    ilp->il_ihp = ihp;
    ihp->ih_tdata = ilp;

    /*
     * Parse the parameters passed in the params nvlist.  The following
     * parameters are required
     *  IPMI_LAN_HOST, IPMI_LAN_USER and IPMI_LAN_PASSWD
     *
     * If any of these were not specified then we abort
     */
    if (nvlist_lookup_string(params, IPMI_LAN_HOST, &hostname) ||
        nvlist_lookup_string(params, IPMI_LAN_USER, &user) ||
        nvlist_lookup_string(params, IPMI_LAN_PASSWD, &authcode)) {
        ipmi_free(ihp, ilp);
        (void) ipmi_set_error(ihp, EIPMI_BADPARAM, NULL);
        return (NULL);
    }
    (void) strncpy(ilp->il_host, hostname, MAXHOSTNAMELEN);
    (void) strncpy(ilp->il_user, user, 16);
    (void) strncpy(ilp->il_authcode, authcode, 16);

    /*
     * IPMI_LAN_PORT is an optional parameter and defaults to port 623
     * IPMI_LAN_PRIVLVL is also optional and defaults to admin
     * IPMI_LAN_TIMEOUT is optional and will default to 3 seconds
     * IPMI_LAN_NUM_RETIES is optional and will default to 5
     */
    if (nvlist_lookup_uint16(params, IPMI_LAN_PORT, &ilp->il_port))
        ilp->il_port = RMCP_UDP_PORT;

    if (nvlist_lookup_uint8(params, IPMI_LAN_PRIVLVL, &ilp->il_privlvl))
        ilp->il_privlvl = IPMI_SESSION_PRIV_ADMIN;

    if (nvlist_lookup_uint32(params, IPMI_LAN_TIMEOUT, &ilp->il_timeout))
        ilp->il_timeout = DEF_IPMI_LAN_TIMEOUT;

    if (nvlist_lookup_uint8(params, IPMI_LAN_NUM_RETRIES,
        &ilp->il_num_retries))
        ilp->il_num_retries = DEF_IPMI_LAN_NUM_RETRIES;

    ilp->il_authtype = IPMI_SESSION_AUTHTYPE_PASSWORD;

    /*
     * Open up and connect a UDP socket between us and the service
     * processor
     */
    ilp->il_addr.sin_family = AF_INET;
    ilp->il_addr.sin_port = htons(ilp->il_port);

    rc = inet_pton(AF_INET, (const char *)ilp->il_host,
        &ilp->il_addr.sin_addr);
    if (rc <= 0) {
        if ((host = gethostbyname((const char *)ilp->il_host))
            == NULL) {
            ipmi_free(ihp, ilp);
            (void) ipmi_set_error(ihp, EIPMI_LAN_OPEN_FAILED, NULL);
            return (NULL);
        }
        ilp->il_addr.sin_family = host->h_addrtype;
        (void) memcpy(&ilp->il_addr.sin_addr, host->h_addr,
            host->h_length);
    }

    if ((ilp->il_sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
        ipmi_free(ihp, ilp);
        (void) ipmi_set_error(ihp, EIPMI_LAN_OPEN_FAILED, NULL);
        return (NULL);
    }
    if (connect(ilp->il_sd, (struct sockaddr *)&ilp->il_addr,
        sizeof (struct sockaddr_in)) < 0) {
        ipmi_lan_close(ilp);
        (void) ipmi_set_error(ihp, EIPMI_LAN_OPEN_FAILED, NULL);
        return (NULL);
    }

    if ((ipmi_req_entries = ipmi_zalloc(ihp, sizeof (ipmi_rq_entry_t)))
        == NULL)
        return (NULL);

    /*
     * Finally we start up the IPMI LAN session
     */
    if ((rc = ipmi_lan_activate_session(ihp)) < 0) {
        ipmi_lan_close(ilp);
        return (NULL);
    }

    return (ilp);
}

ipmi_transport_t ipmi_transport_lan = {
    ipmi_lan_open,
    ipmi_lan_close,
    ipmi_lan_send
};