Logo Search packages:      
Sourcecode: ibutils version File versions  Download package

simmsg.cpp

/*
 * Copyright (c) 2004 Mellanox Technologies LTD. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - 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.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * $Id$
 */

#include <inttypes.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <string>
#include "simmsg.h"
#include <inttypes.h>

#ifndef PRIx64
# if __WORDSIZE == 64
#  define __PRI64_PREFIX   "l"
#  define __PRIPTR_PREFIX  "l"
# else
#  define __PRI64_PREFIX   "ll"
#  define __PRIPTR_PREFIX
# endif
# define PRIx64 __PRI64_PREFIX "x"
#endif

std::string
__ibms_dump_conn_msg(
  IN const ibms_client_msg_t *p_msg)
{
  char buff[32];
  char msg[512];
  strncpy(buff,p_msg->msg.conn.host,31);
  buff[31] = '\0';

  sprintf(msg,"MSG: CONN"
          " Port:%u Guid:0x%016" PRIx64 " Host:%s InPort:%u",
          p_msg->msg.conn.port_num,
          p_msg->msg.conn.port_guid,
          p_msg->msg.conn.host,
          p_msg->msg.conn.in_msg_port
          );
  return msg;
}

std::string
__ibms_dump_disconn_msg(
  IN const ibms_client_msg_t *p_msg)
{
  char buff[32];
  char msg[512];
  strncpy(buff,p_msg->msg.conn.host,31);
  buff[31] = '\0';

  sprintf(msg,"MSG: DISCONNECT "
          " Port:%u Guid:0x%016" PRIx64 "",
          p_msg->msg.disc.port_num,
          p_msg->msg.disc.port_guid
          );
  return msg;
}

std::string
__ibms_dump_cap_msg(
  IN const ibms_client_msg_t *p_msg)
{
  char msg[512];
  sprintf(msg, "MSG: CAP");
  return msg;
}

std::string
__ibms_dump_bind_msg(
  IN const ibms_client_msg_t *p_msg)
{
  char msg[512];
  sprintf(msg, "MSG: BIND");
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_PORT)
    sprintf(msg,"%s Port:%u ",msg, p_msg->msg.bind.port);
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_QP)
    sprintf(msg, "%s QP:%u ", msg, p_msg->msg.bind.qpn);
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_CLASS)
    sprintf(msg, "%s Class:0x%X ", msg, p_msg->msg.bind.mgt_class);
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_METH)
    sprintf(msg, "%s Method:0x%X ", msg, p_msg->msg.bind.method);
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_ATTR)
    sprintf(msg, "%s Attribute:0x%X ", msg, p_msg->msg.bind.attribute);
  if (p_msg->msg.bind.mask & IBMS_BIND_MASK_INPUT)
    if (p_msg->msg.bind.only_input)
      sprintf(msg, "%s Direction:IN",msg);
    else
      sprintf(msg, "%s Direction:IN/OUT", msg);
  return msg;
}

std::string
__ibms_dump_mad_msg(
  IN const ibms_client_msg_t *p_msg)
{
  char msg[1024];
  sprintf(msg,
          "MSG: MAD"
          " ADDRESS:"
          " SLID:0x%04X"
          " DLID:0x%04X"
          " SQPN:%u"
          " DQPN:%u"
          " PKEY:%u"
          " SL:%u"
          " CLASS:0x%02X"
          " METHOD:0x%02X"
          " STATUS:0x%04X"
          " TID:0x%016"PRIx64"",
          p_msg->msg.mad.addr.slid,
          p_msg->msg.mad.addr.dlid,
          p_msg->msg.mad.addr.sqpn,
          p_msg->msg.mad.addr.dqpn,
          p_msg->msg.mad.addr.pkey_index,
          p_msg->msg.mad.addr.sl,
          p_msg->msg.mad.header.mgmt_class,
          p_msg->msg.mad.header.method,
          p_msg->msg.mad.header.status,
          p_msg->msg.mad.header.trans_id);
  return msg;
}

std::string
ibms_get_msg_str(
  IN const ibms_client_msg_t *p_msg)
{
  std::string msgStr;

  switch (p_msg->msg_type) {
  case IBMS_CLI_MSG_CONN:
    msgStr = __ibms_dump_conn_msg(p_msg);
    break;
  case IBMS_CLI_MSG_DISCONN:
    msgStr = __ibms_dump_disconn_msg(p_msg);
    break;
  case IBMS_CLI_MSG_BIND:
    msgStr = __ibms_dump_bind_msg(p_msg);
    break;
  case IBMS_CLI_MSG_CAP:
    msgStr = __ibms_dump_cap_msg(p_msg);
    break;
  case IBMS_CLI_MSG_MAD:
    msgStr = __ibms_dump_mad_msg(p_msg);
    break;
  default:
    msgStr = std::string("MSG: UNDEFINED");
  }
  return msgStr;
}

std::string
ibms_get_mad_header_str(ib_mad_t madHeader)
{
    char msg[1024];

    sprintf(msg,
            "--------------------------------------------------------\n"
            "  base_ver                 0x%x\n"
            "  mgmt_class               0x%x\n"
            "  class_ver                0x%x\n"
            "  method                   0x%x\n"
            "  status                   0x%x\n"
            "  class_spec               0x%x\n"
            "  trans_id                 0x%016"PRIx64"\n"
            "  attr_id                  0x%x\n"
            "  attr_mod                 0x%x\n"
            "--------------------------------------------------------\n",
            madHeader.base_ver,
            madHeader.mgmt_class,
            madHeader.class_ver,
            madHeader.method,
            CL_NTOH16(madHeader.status),
            CL_NTOH16(madHeader.class_spec),
            CL_NTOH64(madHeader.trans_id),
            CL_NTOH16(madHeader.attr_id),
            CL_NTOH32(madHeader.attr_mod));
    return (std::string)msg;
};

std::string
ibms_get_node_info_str(ib_node_info_t*     pNodeInfo)
{
    char msg[1024];

    sprintf(msg,
            "--------------------------------------------------------\n"
            "  node_type                0x%x\n"
            "  num_ports                0x%x\n"
            "  local port number        0x%x\n"
            "--------------------------------------------------------\n",
            pNodeInfo->node_type,
            pNodeInfo->num_ports,
            ib_node_info_get_local_port_num(pNodeInfo));
    return (std::string)msg;
}

std::string
ibms_get_port_info_str(ib_port_info_t*     pPortInfo)
{
    char msg[1024];

    sprintf(msg,
            "--------------------------------------------------------\n"
            "  lid                      0x%x\n"
            "  Port State               0x%x\n"
            "  Port Phy State           0x%x\n"
            "  nMTU                     0x%x\n"
            "  VL Cap                   0x%x\n"
            "  LMC                      0x%x\n"
            "--------------------------------------------------------\n",
            CL_NTOH16(pPortInfo->base_lid),
            ib_port_info_get_port_state(pPortInfo),
            ib_port_info_get_port_phys_state(pPortInfo),
            ib_port_info_get_neighbor_mtu(pPortInfo),
            ib_port_info_get_vl_cap(pPortInfo),
            ib_port_info_get_lmc(pPortInfo)
            );
    return (std::string)msg;
};

void
ibms_dump_msg(
  IN const ibms_client_msg_t *p_msg)
{
  printf("%s", ibms_get_msg_str(p_msg).c_str());
}

char *
ibms_get_resp_str(
  IN const ibms_response_t *p_response)
{
  if (p_response->status)
    return "REMOTE_ERROR";
  else
    return "SUCCESS";
}

Generated by  Doxygen 1.6.0   Back to index