ocs_isns.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

/**
 * @file
 * Implements the iSNS functions.
 */

/**
 * @defgroup isns iSCSI iSNS utilities
 */

#include "ocs.h"
#include "ocs_isns.h"
#include "ocs_iscsi.h"
#include "ocs_iscsi_api.h"

/**
 * @ingroup isns
 * @brief Initialize the iSNS module
 *
 * This function will initialize any iSNS required structures
 *
 * @param iscsi pointer to the iSCSI structure that represents this device
 *
 * @return 0 if success
 */
int32_t
ocs_isns_initialize(ocs_iscsi_t *iscsi)
{
    return 0;
}

/**
 * @ingroup isns
 * @brief Shutdown the iSNS module
 *
 * This function will free any iSNS resources prior to driver shutdown
 *
 * @param iscsi pointer to the iSCSI structure that represents this device
 *
 * @return 0 if success
 */
int32_t
ocs_isns_teardown(ocs_iscsi_t *iscsi)
{
    return 0;
}

/**
 * @ingroup isns
 * @brief Determines whether a given isns attribute is a numeric (binary) one
 *
 * @param tag The tag of the isns attribute in query
 *
 * @return 0 if success
 */
static int
ocs_binary_attr(int tag)
{
    switch (tag){
    case ISNS_TAG_ENTITY_PROTOCOL : return 1;
    case ISNS_TAG_REG_PERIOD : return 1;
    case ISNS_TAG_PORTAL_TCP_PORT : return 1;
    case ISNS_TAG_ESI_INTERVAL : return 1;
    case ISNS_TAG_ESI_PORT : return 1;
    case ISNS_TAG_PORTAL_INDEX : return 1;
    case ISNS_TAG_ISCSI_NODE_TYPE: return 1;
    default: return 0;
    }
}

/**
 * @ingroup isns
 * @brief Prints a number of empty lines
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param ctr the number of empty lines to be printed
 */
static void
ocs_print_nl(ocs_iscsi_t *iscsi, uint32_t ctr)
{
    while(ctr>0) {
        ocs_isns_log(iscsi->os, "\n");
        ctr--;
    }
}

/**
 * @ingroup isns
 * @brief Gets the name of the given isns tag
 *
 * @param tag The number of the tag
 * @return returns the tag name
 */
static char*
ocs_get_tag_name(uint32_t tag)
{
    switch (tag) {
    case ISNS_TAG_DELIMITER : return "delimiter";
    case ISNS_TAG_ENTITY_IDENTIFIER : return "Entity ID";
    case ISNS_TAG_ENTITY_PROTOCOL : return "Entity Protocol";
    case ISNS_TAG_REG_PERIOD : return "Registration Period";
    case ISNS_TAG_PORTAL_IP_ADDRESS : return "Portal IP Address";
    case ISNS_TAG_PORTAL_TCP_PORT : return "Portal TCP/UDP Port";
    case ISNS_TAG_ESI_INTERVAL : return "ESI Interval";
    case ISNS_TAG_ESI_PORT : return "ESI Port";
    case ISNS_TAG_PORTAL_INDEX : return "Portal Index";
    case ISNS_TAG_ISCSI_NAME : return "iSCSI Name";
    case ISNS_TAG_ISCSI_NODE_TYPE : return "iSCSI Node Type";
    case ISNS_TAG_ISCSI_ALIAS : return "iSCSI Alias";
    default : return "Undefined Tag Name";
    }
}

/**
 * @ingroup isns
 * @brief Gets the name of the given isns error
 *
 * @param error_number The number of the error
 * @return returns the error name
 */
static char*
ocs_get_error_name(uint32_t error_number)
{
    switch (error_number) {
    case ISNS_ERROR_UNKNOWN : return "Unknown Error" ;
    case ISNS_ERROR_MSG_FORMAT : return "Message Format Error";
    case ISNS_ERROR_INVALID_REG : return "Invalid Registration";
    case ISNS_ERROR_RESERVED : return "RESERVED";
    case ISNS_ERROR_INVALID_QUERY : return "Invalid Query";
    case ISNS_ERROR_SOURCE_UNKNOWN : return "Source Unknown";
    case ISNS_ERROR_SOURCE_ABSENT : return "Source Absent";
    case ISNS_ERROR_SOURCE_UNATHORIZED : return "Source Unauthorized";
    case ISNS_ERROR_NO_SUCH_ENTRY : return "No Such Entry";
    case ISNS_ERROR_VERSION_NOT_SUPPORTED : return "Version Not Supported";
    case ISNS_ERROR_INTERNAL_ERROR : return "Internal Error";
    case ISNS_ERROR_BUSY : return "Busy";
    case ISNS_ERROR_OPTION_NOT_UNDERSTOOD : return "Option Not Understood";
    case ISNS_ERROR_INVALID_UPDATE : return "Invalid Update";
    case ISNS_ERROR_FUNC_ID : return "Message (FUNCTION_ID) Not Supported";
    case ISNS_ERROR_SCN_EVENT_REJ : return "SCN Event Rejected";
    case ISNS_ERROR_SCN_REG_REJ : return "SCN Registration Rejected";
    case ISNS_ERROR_NOT_IMPL : return "Attribute Not Implemented";
    case ISNS_ERROR_DOMAIN_ID_UNAVAILABLE : return "FC_DOMAIN_ID Not Available";
    case ISNS_ERROR_UNALLCATED_DOMAIN_ID : return "FC_DOMAIN_ID Not Allocated";
    case ISNS_ERROR_ESI_UNAVAILABLE : return "ESI Not Available";
    case ISNS_ERROR_INVALID_DEREG : return "Invalid Deregistration";
    case ISNS_ERROR_REG_FEATURE_UNSUPPORTED : return "Registration Feature Not Supported";
    default : return "UNDEFINED ERROR CODE!";
    }
}

/**
 * @ingroup isns
 * @brief Creates an empty isns node
 *
 * This function will create an empty isns node and allocates memory for
 * the given number of ip_port structs
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param ptr Pointer that determines where to create this node
 * @param num The number of ip-port structs in that node
 * @return returns 0 if successful, negative otherwise.
 */
static int8_t
ocs_create_node(ocs_iscsi_t *iscsi, void *ptr, uint16_t num)
{
    ocs_isns_node_t n;

    ocs_memset(&n, 0, sizeof(ocs_isns_node_t));
    n.ipp_count = num;
    n.ipp = ocs_malloc(iscsi->os, n.ipp_count * sizeof(ocs_isns_ip_port_t), OCS_M_ZERO | OCS_M_NOWAIT);
    if (!n.ipp) {
        ocs_log_test(iscsi->os, "iSNS ERROR: Failed to create the node\n");
        return -1;
    }

    ocs_memcpy(ptr, &n, sizeof(ocs_isns_node_t));
    ocs_isns_log(iscsi->os, "A node created with ipp_count=%d\n", n.ipp_count);
    return 0;
}

/**
 * @ingroup isns
 * @brief Gets the iscsi name of a given node
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param p Pointer to the start of the nodes table
 * @param index determines the index of the node in query
 * @return returns the iscsi name of that node
 */
char *
ocs_get_iscsi_name(ocs_iscsi_t *iscsi, void *p, uint16_t index)
{
    ocs_isns_node_t *n = (ocs_isns_node_t *) (p + index * sizeof(ocs_isns_node_t));
    //ocs_isns_log(iscsi->os, "node #%d has iname = %s\n", index, n->iname);
    return n->iname;
}

/**
 * @ingroup isns
 * @brief Gets the count of the ip_port structs in a given node
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param p Pointer to the start of the nodes table
 * @param index determines the index of the node in query
 * @return returns the number of the ip_port structs in this node
 */
uint16_t
ocs_get_iscsi_ipp_count(ocs_iscsi_t *iscsi, void *p, uint16_t index)
{
    ocs_isns_node_t *n = (ocs_isns_node_t *) (p + index * sizeof(ocs_isns_node_t));
    ocs_isns_log(iscsi->os, "node #%d has ipp_count = %d\n", index, n->ipp_count);
    return n->ipp_count;
}

/**
 * @ingroup isns
 * @brief Converts a string ip into an ip struct
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param *ip Pointer to the ip string
 * @param *ip_struct Pointer to the ip_struct to contain the given string ip
 */
void
ocs_str_to_ip_struct(ocs_iscsi_t *iscsi, char *ip, ocs_ip_address_t *ip_struct)
{
    char v4_start[16] = "0:0:0:0:0:ffff";
    char temp[15];
    uint8_t i;

    if(ip == NULL){
        ocs_log_test(iscsi->os, "iSNS ERROR: ip pointer is NULL");
        return;
    }
    temp[14] = '\0';
    ocs_memcpy(temp, ip, 14);
    if(ocs_strcmp(temp, v4_start)) { //v6
        if(ocs_iscsi_inet_pton6(ip, ip_struct)) {
            ocs_isns_log(iscsi->os, "invalid v6 ip address\n");
            return;
        }
    } else { //v4
        if(ocs_iscsi_inet_pton6(ip, ip_struct)) {
            ocs_isns_log(iscsi->os, "invalid v4 ip address\n");
            return;
        } else {
            ip_struct->ip_type = OCS_IP_TYPE_V4;
            for( i = 0; i < 4; i++) {
                ip_struct->ip_address[i] = ip_struct->ip_address[12 + i];
            }
            for( i = 4; i < 16; i++) {
                ip_struct->ip_address[i] = 0;
            }
        }
    }
    return;
}

/**
 * @ingroup isns
 * @brief Gets the ip address of a given isns node
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param p Pointer to the start of the nodes table
 * @param index determines the index of the node in query
 * @param ip_index determines which ip-port structure to be selected
 * @return returns the ip string of this node
 */
char *
ocs_get_ip(ocs_iscsi_t *iscsi, void *p, uint16_t index, uint16_t ip_index)
{
    ocs_isns_node_t *n = (ocs_isns_node_t *) (p + index * sizeof(ocs_isns_node_t));
    ocs_isns_ip_port_t *ipp = NULL;

    if(ip_index > n->ipp_count - 1) {
        ocs_isns_log(iscsi->os, "This node has only %d ips\n", n->ipp_count);
        return NULL;
    }
    ipp = n->ipp + ip_index;
    return ipp->ip;
}

/**
 * @ingroup isns
 * @brief Gets the port of a given isns node
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param p Pointer to the start of the nodes table
 * @param index determines the index of the node in query
 * @param ip_index determines which ip-port structure to be selected
 * @return returns the port of this node
 */
uint16_t
ocs_get_port(ocs_iscsi_t *iscsi, void *p, uint16_t index, uint16_t ip_index)
{
    ocs_isns_node_t *n = (ocs_isns_node_t *) (p + index * sizeof(ocs_isns_node_t));
    ocs_isns_ip_port_t *ipp = NULL;

    if(ip_index > n->ipp_count - 1) {
        ocs_isns_log(iscsi->os, "This node has only %d ips\n", n->ipp_count);
        return 0;
    }
    ipp = n->ipp + ip_index;
    return ipp->port;
}

/**
 * @ingroup isns
 * @brief Creates an isns node
 *
 * This function will create an isns node by parsing the response message
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param rsp_ptr Pointer to the start of the nodes in the operating attributes
 * @param bytes_left Number of bytes left in the response message
 * @param ret Pointer to the node to be created
 * @return returns 0 if successful, negative otherwise.
 */
static int8_t
ocs_create_nodes(ocs_iscsi_t *iscsi, void *rsp_ptr, int16_t bytes_left, void *ret)
{
    uint8_t passed_first_node = 0;
    uint16_t ipps_count = 0;
    uint16_t nodes_index = 0;
    uint32_t tag, len;

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tCreate an isns node begin\n");

    while (bytes_left > 0) {
        ocs_memcpy(&tag, rsp_ptr, 4);
        tag = ocs_be32toh(tag);
        bytes_left -= 4;
        rsp_ptr += 4;

        ocs_memcpy(&len, rsp_ptr, 4);
        len = ocs_be32toh(len);
        bytes_left -= 4;
        rsp_ptr += 4;

        if(tag == ISNS_TAG_ISCSI_NAME && !(passed_first_node)) {
            passed_first_node = 1;
        } else if (tag == ISNS_TAG_ISCSI_NAME && passed_first_node) {
            ipps_count /= 2;
            ocs_isns_log(iscsi->os, "node #%d has %d ipps\n", nodes_index++, ipps_count);
            if( ocs_create_node(iscsi, ret, ipps_count) != 0){
                ocs_log_err(iscsi->os, "iSNS ERROR: can't create a node!\n");
                return -1;
            }
            ret += sizeof(ocs_isns_node_t);
            ipps_count = 0;
        } else if (tag == ISNS_TAG_PORTAL_IP_ADDRESS || tag == ISNS_TAG_PORTAL_TCP_PORT) {
            ipps_count++;
        } else if (tag == ISNS_TAG_PORTAL_TCP_PORT) {
            /* skip */
        } else {
            ocs_log_test(iscsi->os, "ERROR: UNDEFINED ATTR 0x%x between the NODES!!\n", tag);
            return -1;
        }
        bytes_left -= len;
        rsp_ptr += len;

        if(bytes_left == 0) {//create last node with this num_ipps
            ipps_count /= 2;
            ocs_isns_log(iscsi->os, "node #%d has %d ipps\n", nodes_index++, ipps_count);
            if( ocs_create_node(iscsi, ret, ipps_count) != 0){
                ocs_log_err(iscsi->os, "iSNS ERROR: can't create a node!\n");
                return -1;
            }
            ret += sizeof(ocs_isns_node_t);
        }
    }
    return 0;
}

/**
 * @ingroup isns
 * @brief Fills the attributes of the isns node
 *
 * This function will fills the ip and port attributes of the given node
 * by parsing the response message
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param rsp_ptr Pointer to the start of the nodes in the operating attributes
 * @param bytes_left Number of bytes left in the response message
 * @param ret Pointer to the node to be filled
 */
static void
ocs_fill_nodes_values(ocs_iscsi_t * iscsi, void *rsp_ptr, int16_t bytes_left, void *ret)
{
    uint32_t tag, len;
    uint32_t v32;
    char ip_addr[48];
    ocs_ip_type_e ip_type = OCS_IP_TYPE_V6;
    ocs_isns_node_t *temp_node = NULL;
    ocs_isns_ip_port_t *temp_ipp = NULL;
    uint16_t nodes_index = 0;
    uint16_t ipp_index = 0;

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tISNS node fill attributes\n");

    while (bytes_left > 0) {
        ocs_memcpy(&tag, rsp_ptr, 4);
        tag = ocs_be32toh(tag);
        bytes_left -= 4;
        rsp_ptr += 4;

        ocs_memcpy(&len, rsp_ptr, 4);
        len = ocs_be32toh(len);
        bytes_left -= 4;
        rsp_ptr += 4;

        if(tag == ISNS_TAG_ISCSI_NAME) {
            temp_node = (ocs_isns_node_t *) (ret + nodes_index * sizeof(ocs_isns_node_t));

            ocs_memcpy(temp_node->iname, rsp_ptr, len );
            nodes_index++;
            ipp_index = 0;
        } else if (tag == ISNS_TAG_PORTAL_IP_ADDRESS) {
            format_ip_address(ip_type , rsp_ptr, ip_addr, ARRAY_SIZE(ip_addr) );
            temp_ipp = (ocs_isns_ip_port_t *) (temp_node->ipp + ipp_index);
            ocs_memcpy(temp_ipp->ip, ip_addr, ocs_strlen(ip_addr));

        } else if (tag == ISNS_TAG_PORTAL_TCP_PORT) {
            temp_ipp = (ocs_isns_ip_port_t *) (temp_node->ipp + ipp_index);
            v32 = ocs_htobe32( * (uint32_t *) rsp_ptr);
            ocs_memcpy(&temp_ipp->port, &v32, sizeof(uint32_t));

            ipp_index++;
        } else {
            ocs_log_test(iscsi->os, "ERROR: UNDEFINED ATTR 0x%x between the NODES!!\n", tag);
            return;
        }
        bytes_left -= len;
        rsp_ptr += len;
    }

    ocs_isns_log(iscsi->os, "\t\t\tISNS node fill attributes done\n");
    return;
}

/**
 * @ingroup isns
 * @brief Builds the header of the DevAttrReg message
 *
 * @param curr Pointer to the start of the attribute
 * @param len the length of the PDU of that message
 * @return returns the number of bytes allocated for this attribute
 */
static int
ocs_build_hdr_dev_attr_reg(void *curr, uint16_t len)
{
    isns_hdr_t hdr;
    hdr.iSNSP_version= ocs_htobe16(ISNS_VERSION);
    hdr.function_id= ocs_htobe16(ISNS_FUNC_DEV_ATTR_REG);
    hdr.payload_length= ocs_htobe16(len);
    hdr.flags = ocs_htobe16(ISNS_FLAG_FIRST | ISNS_FLAG_LAST | ISNS_FLAG_REPLACE | ISNS_FLAG_CLIENT) ;
    hdr.transaction_id = ocs_htobe16(ISNS_TRANSACTION_ID_1);
    hdr.sequence_id = ocs_htobe16(ISNS_STARTING_SEQ_ID);
    ocs_memcpy(curr, &hdr, sizeof(isns_hdr_t));
    return sizeof(isns_hdr_t);
}


/**
 * @ingroup isns
 * @brief Builds the header of the DevAttrDereg message
 *
 * @param curr Pointer to the start of the attribute
 * @param len the length of the PDU of that message
 * @return returns the number of bytes allocated for this attribute
 */
static int
ocs_build_hdr_dev_dereg(void *curr, uint16_t len)
{
    isns_hdr_t hdr;
    hdr.iSNSP_version= ocs_htobe16(ISNS_VERSION);
    hdr.function_id= ocs_htobe16(ISNS_FUNC_DEV_ATTR_DEREG);
    hdr.payload_length= ocs_htobe16(len);
    hdr.flags = ocs_htobe16(ISNS_FLAG_FIRST | ISNS_FLAG_LAST | ISNS_FLAG_REPLACE | ISNS_FLAG_CLIENT) ;
    hdr.transaction_id = ocs_htobe16(ISNS_TRANSACTION_ID_1);
    hdr.sequence_id = ocs_htobe16(ISNS_STARTING_SEQ_ID);
    ocs_memcpy(curr, &hdr, sizeof(isns_hdr_t));
    return sizeof(isns_hdr_t);
}

/**
 * @ingroup isns
 * @brief Builds the header of the DevAttrQry message
 *
 * @param curr Pointer to the start of the attribute
 * @param len the length of the PDU of that message
 * @return returns the number of bytes allocated for this attribute
 */
static int
ocs_build_hdr_dev_attr_qry(void *curr, uint16_t len)
{
    isns_hdr_t hdr;
    hdr.iSNSP_version= ocs_htobe16(ISNS_VERSION);
    hdr.function_id= ocs_htobe16(ISNS_FUNC_DEV_ATTR_QRY);
    hdr.payload_length= ocs_htobe16(len);
    hdr.flags = ocs_htobe16(ISNS_FLAG_FIRST | ISNS_FLAG_LAST | ISNS_FLAG_REPLACE | ISNS_FLAG_CLIENT) ;
    hdr.transaction_id = ocs_htobe16(ISNS_TRANSACTION_ID_2);
    hdr.sequence_id = ocs_htobe16(ISNS_STARTING_SEQ_ID);
    ocs_memcpy(curr, &hdr, sizeof(isns_hdr_t));
    return sizeof(isns_hdr_t);
}

/**
 * @ingroup isns
 * @brief Create a delimiter attribute
 *
 * This function will form a delimiter attribute (0-length and 0-tag attribute)
 * for the isns messages
 *
 * @param curr Pointer to the start of the attribute
 * @param remaining the number of bytes left in the memory allocated for this msg
 * @return returns the number of bytes allocated for this attribute
 */
static int ocs_add_delimiter(void *curr, int remaining)
{
    if (remaining < 8)
        return -1;
    ocs_memset( curr, 0, 8);
    return 8;
}

/**
 * @ingroup isns
 * @brief Create a tag-length-value attribute
 *
 * This function will form a tag-length-value-attribute for the isns messages
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param curr Pointer to the start of the attribute
 * @param tag the tag of the attribute
 * @param len the length of the attribute
 * @param value Pointer to the value part of the attribute
 * @param remaining the number of bytes left in the memory allocated for this msg
 *
 * @return returns the number of bytes allocated for this attribute
 */
static int
ocs_add_tlv(ocs_iscsi_t *iscsi, void *curr, uint32_t tag, uint32_t len, void* value, int remaining)
{
    uint32_t t, l;
    int padsize = len & 3;
    int push = 0;

    if (padsize != 0) {
        padsize = 4 - padsize;
    }
    push = 2 * sizeof(uint32_t) + len + padsize;
    if (remaining < push) {
        return -1;
    }
    if (ocs_binary_attr(tag))
    {
        t = ocs_htobe32(tag);
        ocs_memcpy(curr, &t, sizeof(uint32_t));
        curr += sizeof(uint32_t);
        l = ocs_htobe32(len + padsize) ;
        ocs_memcpy(curr, &l, sizeof(uint32_t));
        curr += sizeof(uint32_t);
        switch (len) {
        case 0:
            break;
        case 2:
            *((uint16_t*)curr) = ocs_htobe16( * (uint16_t *) value);
            break;
        case 4:
            *((uint32_t*)curr) = ocs_htobe32( * (uint32_t *) value);
            break;
        case 8:
            *((uint64_t*)curr) = ocs_htobe64( * (uint64_t *) value);
            break;
        default:
            ocs_log_test(iscsi->os, "Error: value attribute must be of size 2, 4, or 8 Bytes.\n");
            return -1;
        }
        curr += len;
    } else {
        t = ocs_htobe32(tag);
        ocs_memcpy(curr, &t, sizeof(uint32_t));
        curr += sizeof(uint32_t);
        l = ocs_htobe32(len + padsize);
        ocs_memcpy(curr, &l, sizeof(uint32_t));
        curr += sizeof(uint32_t);

        ocs_memcpy(curr, value, len);
        curr += len;
    }
    if (padsize != 0)
    {
        ocs_memset(curr, 0, padsize);
        curr += padsize;
    }
    return (push);
}

/**
 * @ingroup isns
 * @brief Forms an v6-format ip string
 *
 * This function will convert an ip address into an ipv6-formatted string
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param addr Pointer to the input ip address
 * @param ret_addr Pointer to the return string
 *
 * @return none
 */
static void
ocs_get_ipv6_string(ocs_iscsi_t *iscsi, ocs_ip_address_t *addr, uint8_t *ret_addr)
{
    int i = 0;

    if ( addr->ip_type == OCS_IP_TYPE_V6 || addr->ip_type == OCS_IP_TYPE_AUTO_V6 ) {
        ocs_memcpy(ret_addr, addr->ip_address, 16);
        return;
    }
    /* map it to ipv6 format if it is ipv4 */
    for(i = 0; i < 10; i++)
        ret_addr[i] = 0x00;
    ret_addr[10] = 0xff;
    ret_addr[11] = 0xff;
    for(i = 0; i < 4; i++)
        ret_addr[12 + i] = addr->ip_address[i];
    return ;
}

/**
 * @ingroup isns
 * @brief Parses the flags of the response of an isns message
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param flags The flags of that message
 */
static void
ocs_parse_flags(ocs_iscsi_t *iscsi, uint16_t flags)
{
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tParsing flags (0x%x)of the response message\n", flags);

    if (flags >> 2 & 1) {
        ocs_isns_log(iscsi->os, "First PDU in the message\n");
    } else {
        ocs_isns_log(iscsi->os, "Not first PDU in the message\n");
    }
    if (flags >> 3 & 1) {
        ocs_isns_log(iscsi->os, "Last PDU in the message\n");
    } else {
        ocs_isns_log(iscsi->os, "Not last PDU in the message\n");
    }
    if (flags >> 4 & 1) {
        ocs_isns_log(iscsi->os, "Replace bit = true\n");
    } else {
        ocs_isns_log(iscsi->os, "Replace bit = false\n");
    }
    if (flags >> 5 & 1) {
        ocs_isns_log(iscsi->os, "Authentication Block = true\n");
    } else {
        ocs_isns_log(iscsi->os, "No Authentication Block\n");
    }
    if (flags >> 6 & 1) {
        ocs_isns_log(iscsi->os, "Sender is a server\n");
    } else {
        ocs_isns_log(iscsi->os, "Sender is NOT a server\n");
    }
    if (flags >> 7 & 1) {
        ocs_isns_log(iscsi->os, "Sender is a client\n");
    } else {
        ocs_isns_log(iscsi->os, "Sender is NOT a client\n");
    }
}

/**
 * @ingroup isns
 * @brief Parses the header of the response of an isns message
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param rsp Pointer to the header of the response message
 */
static void
ocs_parse_rsp_hdr(ocs_iscsi_t *iscsi, void *rsp)
{
    uint16_t version, func_id, payload_len, flags, transaction_id, sequence_id;

    //ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tISNS: PARSING THE HEADER OF THE RSP MSG\n");

    ocs_memcpy(&version, rsp, 2);
    rsp += 2;

    ocs_memcpy(&func_id, rsp, 2);
    rsp += 2;

    ocs_memcpy(&payload_len, rsp, 2);
    rsp += 2;

    ocs_memcpy(&flags, rsp, 2);
    rsp += 2;

    ocs_memcpy(&transaction_id, rsp, 2);
    rsp += 2;

    ocs_memcpy(&sequence_id, rsp, 2);
    rsp += 2;

    ocs_isns_log(iscsi->os, "version is (%x) \n", ocs_be16toh(version));
    ocs_isns_log(iscsi->os, "func_id is (%d) \n", ocs_be16toh(func_id));
    ocs_isns_log(iscsi->os, "payload_len is (%d) \n", ocs_be16toh(payload_len));
    ocs_isns_log(iscsi->os, "flags is (0x%x) \n", ocs_be16toh(flags));
    ocs_isns_log(iscsi->os, "transaction_id is (%d) \n", ocs_be16toh(transaction_id));
    ocs_isns_log(iscsi->os, "sequence_id is (%d) \n", ocs_be16toh(sequence_id));
    ocs_parse_flags(iscsi, flags);
    return;
}

/**
 * @ingroup isns
 * @brief Parses the response of the DevAttrQry message
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param rsp_ptr Pointer to the start of the response
 * @param rsp_len the length of the response
 * @param ret_nodes_count Pointer to the number of discovered targets
 * @return returns Pointer to the table of the discovered registered targets, NULL if error
 */
static void *
ocs_parse_qry_rsp(ocs_iscsi_t *iscsi, void *rsp_ptr, uint16_t rsp_len, uint16_t *ret_nodes_count)
{
    uint32_t error_code = 0;
    int16_t bytes_left = rsp_len;
    uint32_t tag, len;
    uint8_t counter = 0;
    uint8_t delimiter_parsed = 0;
    uint16_t v16;
    uint32_t v32;
    uint64_t v64;
    void *void_v = NULL;
    ocs_ip_type_e ip_type = OCS_IP_TYPE_V6;
    char ip_addr[48];
    uint16_t nodes_count = 0;
    void *ret = NULL;
    void *nodes_ptr = NULL;
    uint16_t bleft = 0;

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tISNS: parse query resp\n");

    ocs_parse_rsp_hdr(iscsi, rsp_ptr);
    bytes_left -= sizeof(isns_hdr_t);
    rsp_ptr += sizeof(isns_hdr_t);

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tPARSING THE PDU OF THE RSP MSG\n");

    ocs_memcpy(&error_code, rsp_ptr, 4);
    error_code = ocs_be32toh(error_code);
    bytes_left -= 4;
    rsp_ptr += 4;
    //??need to check for Transaction id and seq id values.
    if (error_code == 0) {
        ocs_isns_log(iscsi->os, "error code = %d (SUCCESS!) \n", error_code);
    } else {
        ocs_log_test(iscsi->os, "FAILURE: ISNS Query Response Message has error code = %s (%d)\n", ocs_get_error_name(error_code), error_code);
        return NULL;
    }

    ocs_isns_log(iscsi->os, "PDU Length = %d\n", bytes_left + 4 ); // +4 bytes for the error code
    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "\t\t\tPRINTING PDU ATTRIBUTES IN THE QRY RSP MSG\n");
    ocs_print_nl(iscsi, 1);
    while (bytes_left > 0) {
        counter++;

        ocs_memcpy(&tag, rsp_ptr, 4);
        tag = ocs_be32toh(tag);
        bytes_left -= 4;
        rsp_ptr += 4;

        ocs_memcpy(&len, rsp_ptr, 4);
        len = ocs_be32toh(len);
        bytes_left -= 4;
        rsp_ptr += 4;

        if (tag == ISNS_TAG_DELIMITER ) {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* DELIMITER *********\n");
            delimiter_parsed = 1;
            counter = 0;

            /* for the second loop */
            nodes_ptr = rsp_ptr;
            bleft = bytes_left;
        } else if (delimiter_parsed ) {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* Operating Attribute #%d *********\n", counter);
        } else {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* Message Key Attribute #%d *********\n", counter);
        }

        ocs_isns_log(iscsi->os, "tag = %s (%d)\n", ocs_get_tag_name(tag), tag);
        ocs_isns_log(iscsi->os, "length = %d\n", len);

        if (tag == ISNS_TAG_DELIMITER && len == 0 ) {
            ocs_isns_log(iscsi->os, "value = NO VALUE (DELIMITER ATTR.)\n");
        } else if (ocs_binary_attr(tag)) {
            switch (len) {
            case 0:
                ocs_isns_log(iscsi->os, "value = NO VALUE! [Binary Attr but has length = 0]\n");
                break;
            case 2:
                v16 = ocs_htobe16( * (uint16_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v16) = %d\n", v16);
                break;
            case 4:
                v32 = ocs_htobe32( * (uint32_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v32) = %d\n", v32);
                break;
            case 8:
                v64 = ocs_htobe64( * (uint64_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v64) = %" PRId64 " \n", v64);
                break;
            default:
                ocs_log_test(iscsi->os, "Error: value attribute must be of size 2, 4, or 8 Bytes.\n");
                return NULL;
            }
        } else if (tag == ISNS_TAG_PORTAL_IP_ADDRESS) {
            format_ip_address(ip_type , rsp_ptr,
                      ip_addr, ARRAY_SIZE(ip_addr) );
            ocs_isns_log(iscsi->os, "value (special) = %s\n",  ip_addr);
        } else {
            void_v = ocs_malloc(iscsi->os, len, OCS_M_ZERO | OCS_M_NOWAIT);
            if(void_v == NULL){
                ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory len %d\n", len);
                return NULL;
            }
            ocs_memcpy(void_v, rsp_ptr, len);
            ocs_isns_log(iscsi->os, "value (void) = %s\n", (char *) void_v);
            ocs_free(iscsi->os, void_v, len);
            void_v = NULL;
        }
        bytes_left -= len;
        rsp_ptr += len;

        if(tag == ISNS_TAG_ISCSI_NAME) {
            nodes_count++;
        }
    }

    ocs_print_nl(iscsi, 3);
    if(nodes_count !=  0) {
        ocs_isns_log(iscsi->os, "nodes_count = %u\n", nodes_count);
        *ret_nodes_count = nodes_count;
        /* second loop: create nodes */
        ret = ocs_malloc(iscsi->os, nodes_count * sizeof(ocs_isns_node_t), OCS_M_ZERO | OCS_M_NOWAIT);
        if(ret == NULL){
            ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory, nodes_count %d\n",
                    nodes_count);
            return NULL;
        }
        if(ocs_create_nodes(iscsi, nodes_ptr, bleft, ret) != 0){
            ocs_log_err(iscsi->os, "Error: can't create nodes\n");
            ocs_free(iscsi->os, ret, nodes_count * sizeof(ocs_isns_node_t));
            return NULL;
        }
        /* third loop: fill those nodes */
        ocs_fill_nodes_values(iscsi, nodes_ptr, bleft, ret);
    } else {
        ocs_isns_log(iscsi->os, "No second loop as nodes_count = 0\n");
        return NULL;
    }
    return ret;
}

/**
 * @ingroup isns
 * @brief Sends the DevAttrReg message to the iSNS server.
 *
 * This function will query the iSCSI device with
 * the isns server to get all the registered targets
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param isns_ip Pointer to the IP address of the iSNS server
 * @param ret_nodes_count Pointer to the number of nodes registered
 *
 * @return Pointer to the table of the discovered registered targets
 */
void *
ocs_isns_qry_tgts(ocs_iscsi_t *iscsi, ocs_ip_address_t *isns_ip, uint16_t *ret_nodes_count)
{
    ocs_t *ocs = iscsi->os;
    void *msg_ptr = NULL;
    void *current_ptr = NULL;
    char *iscsi_name;
    char ip_addr[48];
    int bytes_added = 0;
    uint32_t payload_len = 0;
    int32_t rc;
    uint32_t msg_len;
    ocs_ip_address_t *ip_addr_struct;
    uint32_t node_type = 0x00000001;
    void *ret_ptr = NULL;

    msg_ptr = ocs_malloc(ocs, PDU_MEM_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
    if(msg_ptr == NULL){
        ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory\n");
        return NULL;
    }
    current_ptr = msg_ptr + sizeof(isns_hdr_t);

    iscsi_name = ocs_iscsi_tgt_get_names(ocs, 0);
    if(iscsi_name == NULL){
        ocs_log_test(iscsi->os, "iSNS ERROR: Failed to get iSCSI name\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, 0);
    if(ip_addr_struct == NULL){
        ocs_log_test(iscsi->os, "iSNS ERROR: Failed to get ip address\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    format_ip_address(ip_addr_struct->ip_type , ip_addr_struct->ip_address,
              ip_addr, ARRAY_SIZE(ip_addr) );
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tiSNS query tgts begin\n");
    ocs_isns_log(iscsi->os, "***iscsi name is (%s) \n", iscsi_name);
    ocs_isns_log(iscsi->os, "***its length=%d Bytes\n", (int) ocs_strlen(iscsi_name));

    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "\t\t\tForming the PDU (adding tlv attrs)\n");
    ocs_print_nl(iscsi, 1);

    //1-src attr =iscsi name
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  ocs_strlen(iscsi_name),
                  iscsi_name, PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "1- iSCSI name added, current_ptr moved %d bytes\n",
             bytes_added);

    //2- iSCSI Node Type
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NODE_TYPE, sizeof(uint32_t), &node_type,
                  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "2- iSCSI node type added, current_ptr moved %d bytes\n",
             bytes_added);

    //3- delimiterc
    bytes_added = ocs_add_delimiter(current_ptr,  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "3- delimiter added, current_ptr moved %d bytes\n",
             bytes_added);

    //empty attrs: ip addr, port, and iscsi name
    //4- portal ip address
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_IP_ADDRESS, 0, NULL,
                  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "6- (EMPTY) portal ip address (%s) added, current_ptr moved %d bytes\n",
             ip_addr, bytes_added);

    //5- portal TCP Port
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_TCP_PORT, 0, NULL,
                  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "7- (EMPTY) portal TCP port added, current_ptr moved %d bytes\n",
             bytes_added);

    //6- iscsi name
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  0, NULL,
                  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, "8- (EMPTY) iSCSI name added, current_ptr moved %d bytes\n",
             bytes_added);


    payload_len = current_ptr - msg_ptr - sizeof(isns_hdr_t);
    msg_len = payload_len + sizeof(isns_hdr_t);
    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "payload_len= %u, nmsg_len= %u\n", payload_len, msg_len);

    //0- build and add the header of the DevAttrQuery
    bytes_added = ocs_build_hdr_dev_attr_qry(msg_ptr, (uint16_t) payload_len);
    if (bytes_added != 12) {
        ocs_log_test(iscsi->os, "EROR: ISNS  error in building the header of the message\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return NULL;
    }
    ocs_isns_log(iscsi->os , "size of header is: %d\n", (int) sizeof(isns_hdr_t) );
    ocs_isns_log(iscsi->os, "\t\t\tI WILL SEND NOW!\n");
    rc = ocs_iscsi_isns_send(ocs, isns_ip,
                 3205, // tcp port
                 msg_ptr,
                 &msg_len,
                 PDU_MEM_SIZE);

    if (rc == 0) {
        ocs_isns_log(ocs, "iSNS Send Sent, received %d bytes\n",
                 msg_len);
        if (msg_len > 0) {
            ret_ptr = ocs_parse_qry_rsp(&ocs->iscsi, msg_ptr, msg_len, ret_nodes_count);
            if(ret_ptr == NULL){
                ocs_log_test(iscsi->os, "EROR: ISNS error in parsing the query response\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return NULL;
            }
        }
    } else {
        ocs_isns_log(ocs, "iSNS Send failed with rc %d\n",
                 rc);
    }
    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tEND OF ISNS FUNCTION\n");
    ocs_isns_log(iscsi->os, "==============================================================================\n");
    return ret_ptr;
}

/**
 * @ingroup isns
 * @brief Parses the response of an isns message
 *
 * This function will create an empty isns node and allocates memory for
 * the given number of ip_port structs
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param original_func_name Pointer to the name of the source message
 * @param rsp_ptr Pointer to the response
 * @param rsp_len The length of that response
 * @param reg_period Pointer to the registration period variable
 * @param eid The entity ID assigned by the iSNS server during registration
 *
 * @return returns 0 if successful, negative otherwise
 */
static int8_t
ocs_parse_msg_rsp(ocs_iscsi_t *iscsi, const char *original_func_name, void *rsp_ptr, uint16_t rsp_len, uint32_t *reg_period, char * eid)
{
    uint32_t error_code = 0;
    int16_t bytes_left = rsp_len;
    uint32_t tag, len;
    uint8_t counter = 0;
    uint8_t delimiter_parsed = 0;
    uint16_t v16;
    uint32_t v32 = 0;
    uint64_t v64;
    void *void_v = NULL;
    ocs_ip_type_e ip_type = OCS_IP_TYPE_V6;
    char ip_addr[48];

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tiSNS parse msg resp\n");

    ocs_parse_rsp_hdr(iscsi, rsp_ptr);
    bytes_left -= sizeof(isns_hdr_t);
    rsp_ptr += sizeof(isns_hdr_t);

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tPARSING THE PDU OF THE RSP of the %s MSG\n", original_func_name);

    ocs_memcpy(&error_code, rsp_ptr, 4);
    error_code = ocs_be32toh(error_code);
    bytes_left -= 4;
    rsp_ptr += 4;
    //??need to check for Transaction id and seq id values.
    if (error_code == 0) {
        ocs_isns_log(iscsi->os, "error code = %d (SUCCESS!) \n", error_code);
    } else {
        ocs_log_test(iscsi->os, "FAILURE: Response Message of the %s function has error code = %s (%d)\n", original_func_name, ocs_get_error_name(error_code), error_code);
        return -1;
    }


    ocs_isns_log(iscsi->os, "PDU Length = %d\n", bytes_left + 4 ); // +4 bytes for the error code
    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "\t\t\tPRINTING PDU ATTRIBUTES\n");
    ocs_print_nl(iscsi, 1);
    while (bytes_left > 0) {
        counter++;

        ocs_memcpy(&tag, rsp_ptr, 4);
        tag = ocs_be32toh(tag);
        bytes_left -= 4;
        rsp_ptr += 4;

        ocs_memcpy(&len, rsp_ptr, 4);
        len = ocs_be32toh(len);
        bytes_left -= 4;
        rsp_ptr += 4;
        if (tag == ISNS_TAG_DELIMITER ) {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* DELIMITER *********\n");
            delimiter_parsed = 1;
            counter = 0;
        } else if (delimiter_parsed ) {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* Operating Attribute #%d *********\n", counter);
        } else {
            ocs_print_nl(iscsi, 1);
            ocs_isns_log(iscsi->os, "********* Message Key Attribute #%d *********\n", counter);
        }

        ocs_isns_log(iscsi->os, "tag = %s (%d)\n", ocs_get_tag_name(tag), tag);
        ocs_isns_log(iscsi->os, "length = %d\n", len);

        if (tag == ISNS_TAG_DELIMITER && len == 0 ) {
            ocs_isns_log(iscsi->os, "value = NO VALUE (DELIMITER ATTR.)\n");
        } else if (ocs_binary_attr(tag)) {
            switch (len) {
            case 0:
                ocs_isns_log(iscsi->os, "value = NO VALUE! [Binary Attr but has length = 0]\n");
                break;
            case 2:
                v16 = ocs_htobe16( * (uint16_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v16) = %d\n", v16);
                break;
            case 4:
                v32 = ocs_htobe32( * (uint32_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v32) = %d\n", v32);
                break;
            case 8:
                v64 = ocs_htobe64( * (uint64_t *) rsp_ptr);
                ocs_isns_log(iscsi->os, "value (v64) = %" PRId64 "\n", v64);
                break;
            default:
                ocs_log_test(iscsi->os, "Error: value attribute must be of size 2, 4, or 8 Bytes.\n");
                return -2;
            }
        } else if (tag == ISNS_TAG_PORTAL_IP_ADDRESS) {
            format_ip_address(ip_type , rsp_ptr,
                      ip_addr, ARRAY_SIZE(ip_addr) );
            ocs_isns_log(iscsi->os, "value (special) = %s\n",  ip_addr);
        } else {
            void_v = ocs_malloc(iscsi->os, len, OCS_M_ZERO | OCS_M_NOWAIT);
            if(void_v == NULL){
                ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory len %d\n", len);
                return -1;
            }
            ocs_memcpy(void_v, rsp_ptr, len);
            ocs_isns_log(iscsi->os, "value (void) = %s\n", (char *) void_v);
            ocs_free(iscsi->os, void_v, len);

            if(tag == ISNS_TAG_ENTITY_IDENTIFIER){
                ocs_print_nl(iscsi, 10);
                ocs_memcpy(eid, rsp_ptr, len);
            }
        }
        if(tag == ISNS_TAG_REG_PERIOD) {
            *reg_period = v32;
        }
        bytes_left -= len;
        rsp_ptr += len;
        //ocs_isns_log(iscsi->os, "Bytes left = %d\n", bytes_left);
    }
    return 0;
}

/**
 * @ingroup isns
 * @brief Sends the DevAttrReg message to the iSNS server.
 *
 * This function will query the iSCSI device with
 * the isns server to get all the registered targets
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param isns_ip Pointer to the IP address of the iSNS server
 *
 * @return Pointer to the table of the discovered registered targets
 */
static void *
ocs_isns_qry_attr(ocs_iscsi_t *iscsi, ocs_ip_address_t *isns_ip)
{
    ocs_t *ocs = iscsi->os;
    void *msg_ptr = NULL;
    void *current_ptr = NULL;
    char *iscsi_name;
    char ip_addr[48];
    int bytes_added = 0;
    uint32_t payload_len = 0;
    int32_t rc;
    uint32_t msg_len;
    ocs_ip_address_t *ip_addr_struct;
    uint32_t node_type = 0x00000001;
    void *ret_ptr = NULL;
    uint32_t nodes_index = 0;
    uint16_t *ret_nodes_count = NULL;

    msg_ptr = ocs_malloc(ocs, PDU_MEM_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
    if(msg_ptr == NULL){
        ocs_log_test(iscsi->os, "iSNS ERROR: Failed to allocate memory\n");
        return NULL;
    }
    current_ptr = msg_ptr + sizeof(isns_hdr_t);

    ocs_isns_log(iscsi->os, "\t\t\tiSNS query attr begin\n");
    iscsi_name = ocs_iscsi_tgt_get_names(ocs, nodes_index);
    while(iscsi_name) {
        current_ptr = msg_ptr + sizeof(isns_hdr_t);
        ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, 0);
        if(ip_addr_struct == NULL) {
            ocs_log_test(iscsi->os, "iSNS ERROR: Failed to get ip address\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        format_ip_address(ip_addr_struct->ip_type , ip_addr_struct->ip_address,
                  ip_addr, ARRAY_SIZE(ip_addr) );
        ocs_print_nl(iscsi, 2);
        ocs_isns_log(iscsi->os, "***iscsi name #%u is (%s) \n", nodes_index, iscsi_name);
        ocs_isns_log(iscsi->os, "***its length=%d Bytes\n", (int) ocs_strlen(iscsi_name));

        ocs_print_nl(iscsi, 1);
        ocs_isns_log(iscsi->os, "\t\t\tForming the PDU (adding tlv attrs)\n");
        ocs_print_nl(iscsi, 1);

        //1-src attr =iscsi name
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  ocs_strlen(iscsi_name),
                      iscsi_name, PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "1- iSCSI name added, current_ptr moved %d bytes\n",
                 bytes_added);

        //2- iSCSI Node Type
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NODE_TYPE, sizeof(uint32_t), &node_type,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "2- iSCSI node type added, current_ptr moved %d bytes\n",
                 bytes_added);

        //3- delimiter
        bytes_added = ocs_add_delimiter(current_ptr,  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "3- delimiter added, current_ptr moved %d bytes\n",
                 bytes_added);

        //empty Alias to query it
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_ALIAS,  0, NULL,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "-- (EMPTY) Alias added, current_ptr moved %d bytes\n",
                 bytes_added);


        payload_len = current_ptr - msg_ptr - sizeof(isns_hdr_t);
        msg_len = payload_len + sizeof(isns_hdr_t);
        ocs_print_nl(iscsi, 1);
        ocs_isns_log(iscsi->os, "payload_len= %u, nmsg_len= %u\n", payload_len, msg_len);

        //0- build and add the header of the DevAttrQuery
        bytes_added = ocs_build_hdr_dev_attr_qry(msg_ptr, (uint16_t) payload_len);
        if (bytes_added != 12) {
            ocs_log_test(iscsi->os, "ERROR: ISNS  error in building the header of the message\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return NULL;
        }
        ocs_isns_log(iscsi->os , "size of header is: %d\n", (int) sizeof(isns_hdr_t) );
        ocs_isns_log(iscsi->os, "\t\t\tI WILL SEND NOW!\n");
        rc = ocs_iscsi_isns_send(ocs, isns_ip,
                     3205, // tcp port
                     msg_ptr,
                     &msg_len,
                     PDU_MEM_SIZE);

        if (rc == 0) {
            ocs_isns_log(ocs, "iSNS Send Sent, received %d bytes\n", msg_len);
            if (msg_len > 0) {
                ret_ptr = ocs_parse_qry_rsp(&ocs->iscsi, msg_ptr, msg_len, ret_nodes_count);
                if(ret_ptr == NULL){
                    ocs_log_test(iscsi->os, "EROR: ISNS: error in parsing the query response\n");
                    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                    return NULL;
                }
            }
        } else {
            ocs_isns_log(ocs, "iSNS Send failed with rc %d\n", rc);
        }
        if(ret_ptr == NULL) {
            ocs_log_test(ocs, "FAILED at index %u !\n", nodes_index);
        }
        ocs_print_nl(iscsi, 2);
        nodes_index++;
        iscsi_name = ocs_iscsi_tgt_get_names(ocs, nodes_index);
    }
    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tEND OF ISNS FUNCTION\n");
    ocs_isns_log(iscsi->os, "==============================================================================\n");

    return ret_ptr;
}

/**
 * @brief Sends a query to an ISNS target to keep it alive
 *
 * This function sends a query to the disovered targets to keep them alive (if ESI is no present)
 *
 * @param arg Pointer to the ocs structure
 *
 */
static void
ocs_isns_keep_alive(void *arg) {
    ocs_t *ocs = (ocs_t *) arg;
    uint32_t cycle_period = ocs->iscsi.isns_reg_period;
    void *qry_rsp_ptr = NULL;

    ocs_isns_log(ocs, "cycle_period = %u msec.\n", cycle_period);
    qry_rsp_ptr = ocs_isns_qry_attr(&ocs->iscsi, &ocs->iscsi.isns_ip);
    if(qry_rsp_ptr == NULL) {
        ocs_log_debug(ocs, "iSNS ERROR: ISNS ATTR QRY FAILED! but wont return\n");
        //return;
    }
    cycle_period = 20 * 1000;
    ocs_setup_timer(ocs, &ocs->iscsi.isns_timer,
            ocs_isns_keep_alive,
            ocs,
            cycle_period, false);
    return;
}

/**
 * @ingroup isns
 * @brief Sends the DevAttrReg message to the iSNS server.
 *
 * This function will register all targets in this iSCSI device with
 * the isns server.
 *
 * @param iscsi Pointer to the iSCSI structure that represents this device
 * @param reg_tgts to determine whether to register targets or not
 * @param reg_ini to determine whether to register initiators or not
 * @param isns_ip Pointer to the IP address of the iSNS server
 * @param eid The entity ID assigned by the iSNS server during registration
 *
 * @return returns zero if successful, negative otherwise
 */
int8_t
ocs_isns_register(ocs_iscsi_t *iscsi, uint8_t reg_tgts, uint8_t reg_ini, ocs_ip_address_t *isns_ip, char *eid)
{
    ocs_t *ocs = iscsi->os;
    void *msg_ptr = NULL;
    void *current_ptr = NULL;
    char *iscsi_name;
    char ip_addr[48];
    char *alias;
    int bytes_added = 0;
    uint32_t payload_len = 0;
    int32_t rc;
    uint32_t msg_len;
    ocs_ip_address_t *ip_addr_struct;
    uint32_t node_type = 0x00000001;
    uint32_t tcp_port = OCS_ISCSI_TCP_PORT;
    uint32_t iscsi_prtcl = ISCSI_PROTOCOL;
    uint32_t esi_interval = ISNS_ESI_INTERVAL;
    uint32_t esi_port = ISNS_ESI_PORT;
    uint8_t ipv6_addr[16];
    uint32_t  ctr = 0;
    uint32_t index = 0;
    uint32_t reg_period = 0;
    uint32_t cycle_period;

    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tiSNS register function begin with index = %u\n", index);

    msg_ptr = ocs_malloc(ocs, PDU_MEM_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
    if(msg_ptr == NULL){
        ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory\n");
        return -1;
    }
    current_ptr = msg_ptr + sizeof(isns_hdr_t);

    /* the tgts part */
    if(reg_tgts) {
        ocs_isns_log(iscsi->os, "\t\t\tSTART OF ISNS tgts part\n");
        iscsi_name = ocs_iscsi_tgt_get_names(ocs, index);
        alias = ocs_iscsi_tgt_get_alias(ocs, index);

        ocs_print_nl(iscsi, 1);
        ocs_isns_log(iscsi->os, "\t\t\tForming the PDU (adding tlv attrs)\n");
        ocs_print_nl(iscsi, 1);
        //1-src attr =iscsi name
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  ocs_strlen(iscsi_name),
                      iscsi_name, PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "1- iSCSI name added, current_ptr moved %d bytes\n",
                 bytes_added);

        //2- key attr (EID but empty in our case)
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ENTITY_IDENTIFIER, 0, NULL,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "2- MSG Key attr (EID but empty in our case), current_ptr moved %d bytes\n",
                 bytes_added);

        //3- delimiter
        bytes_added = ocs_add_delimiter(current_ptr,  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "3- delimiter added, current_ptr moved %d bytes\n",
                 bytes_added);


        //4- no EID
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ENTITY_IDENTIFIER, 0, NULL,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "4- (Empty) EID, current_ptr moved %d bytes\n",
                 bytes_added);


        //5- protocol name (value of 2 means it is iSCSI protocol)
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ENTITY_PROTOCOL, sizeof(uint32_t), &iscsi_prtcl,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "5- protocol name added, current_ptr moved %d bytes\n",
                 bytes_added);

        //6- portal ip address
        ocs_isns_log(iscsi->os, "*****Multiple IP Addresses*****\n");
        ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, ctr);
        while (ip_addr_struct) {
            format_ip_address(ip_addr_struct->ip_type , ip_addr_struct->ip_address,
                      ip_addr, ARRAY_SIZE(ip_addr) );
            ocs_get_ipv6_string(&ocs->iscsi, ip_addr_struct, ipv6_addr);
            ocs_isns_log(iscsi->os, "****ip_addr is (%s). its length=%d Bytes \n",  ip_addr, (int) ocs_strlen(ip_addr));
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_IP_ADDRESS, sizeof(ipv6_addr), ipv6_addr,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "6- portal ip address (%s) added, current_ptr moved %d bytes\n",
                     ip_addr, bytes_added);


            //7- portal TCP Port
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_TCP_PORT, sizeof(uint32_t), &tcp_port,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "7- portal TCP port added, current_ptr moved %d bytes\n",
                     bytes_added);

            /* Only register for ESI on the DHCP address */
            if (ISNS_ENABLE_ESI && ip_addr_struct->ip_type == OCS_IP_TYPE_DHCP_V4) {
                //portal ESI interval
                bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ESI_INTERVAL, sizeof(uint32_t), &esi_interval,
                              PDU_MEM_SIZE - (msg_ptr - current_ptr) );
                if (bytes_added <= 0) {
                    ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                    return -1;
                }
                current_ptr += bytes_added;
                ocs_isns_log(iscsi->os, "7- ESI interval added, current_ptr moved %d bytes\n",
                         bytes_added);

                //portal ESI Port
                bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ESI_PORT, sizeof(uint32_t), &esi_port,
                              PDU_MEM_SIZE - (msg_ptr - current_ptr) );
                if (bytes_added <= 0) {
                    ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                    return -1;
                }
                current_ptr += bytes_added;
                ocs_isns_log(iscsi->os, "7- ESI port added, current_ptr moved %d bytes\n",
                         bytes_added);
            }

            ctr++;
            ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, ctr);
            ocs_print_nl(iscsi, 1);
        }



        while(iscsi_name) {
            //8- iscsi name
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  ocs_strlen(iscsi_name), iscsi_name,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "8- iSCSI name added, current_ptr moved %d bytes\n",
                     bytes_added);

            //9= iSCSI Node Type
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NODE_TYPE, sizeof(uint32_t), &node_type,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "9- iSCSI node type added, current_ptr moved %d bytes\n",
                     bytes_added);


            //10- iscsi Alias
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_ALIAS, ocs_strlen(alias), alias,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "10- iSCSI name alias added, current_ptr moved %d bytes\n",
                     bytes_added);

            index++;
            iscsi_name = ocs_iscsi_tgt_get_names(ocs, index);
            alias = ocs_iscsi_tgt_get_alias(ocs, index);
            ocs_print_nl(iscsi, 1);
        }
    }
    /* end of the tgts part */

    /* the initiator part */
    if(reg_ini) {
        node_type = 0x00000002;
        ctr = 0;
        iscsi_name = ocs_iscsi_ini_get_name(ocs);
        alias = ocs_iscsi_ini_get_alias(ocs);
        ocs_print_nl(iscsi, 2);
        ocs_isns_log(iscsi->os, "\t\t\tSTART OF ISNS initiator part\n");
        ocs_isns_log(iscsi->os, "***iscsi name is (%s) \n", iscsi_name);
        ocs_isns_log(iscsi->os, "***its length=%d Bytes\n", (int) ocs_strlen(iscsi_name));
        ocs_isns_log(iscsi->os, "***alias is (%s) \n",  alias);
        ocs_isns_log(iscsi->os, "***its length=%d Bytes\n", (int) ocs_strlen(alias));
        ocs_isns_log(iscsi->os, "***Portal TCP Port is (%d) \n",  tcp_port);
        ocs_isns_log(iscsi->os, "***its length=%d Bytes\n", (int) sizeof(uint32_t));

        ocs_print_nl(iscsi, 1);
        ocs_isns_log(iscsi->os, "\t\t\tForming the PDU (adding tlv attrs)\n");
        ocs_print_nl(iscsi, 1);

        //6- portal ip address
        ocs_isns_log(iscsi->os, "*****Multiple IP Addresses*****\n");
        ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, ctr);
        while (ip_addr_struct) {
            format_ip_address(ip_addr_struct->ip_type , ip_addr_struct->ip_address,
                      ip_addr, ARRAY_SIZE(ip_addr) );
            ocs_get_ipv6_string(&ocs->iscsi, ip_addr_struct, ipv6_addr);
            ocs_isns_log(iscsi->os, "****ip_addr is (%s). its length=%d Bytes \n",  ip_addr, (int) ocs_strlen(ip_addr));
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_IP_ADDRESS, sizeof(ipv6_addr), ipv6_addr,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "6- portal ip address (%s) added, current_ptr moved %d bytes\n",
                     ip_addr, bytes_added);


            //7- portal TCP Port
            bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_PORTAL_TCP_PORT, sizeof(uint32_t), &tcp_port,
                          PDU_MEM_SIZE - (msg_ptr - current_ptr) );
            if (bytes_added <= 0) {
                ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -1;
            }
            current_ptr += bytes_added;
            ocs_isns_log(iscsi->os, "7- portal TCP port added, current_ptr moved %d bytes\n",
                     bytes_added);

            ctr++;
            ip_addr_struct = ocs_iscsi_tgt_get_ip_address(ocs, iscsi_name, ctr);
            ocs_print_nl(iscsi, 1);
        }


        //8- iscsi name
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME,  ocs_strlen(iscsi_name), iscsi_name,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "8- iSCSI name added, current_ptr moved %d bytes\n",
                 bytes_added);

        //9= iSCSI Node Type
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NODE_TYPE, sizeof(uint32_t), &node_type,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "9- iSCSI node type added, current_ptr moved %d bytes\n",
                 bytes_added);


        //10- iscsi Alias
        bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_ALIAS, ocs_strlen(alias), alias,
                      PDU_MEM_SIZE - (msg_ptr - current_ptr) );
        if (bytes_added <= 0) {
            ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
            ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
            return -1;
        }
        current_ptr += bytes_added;
        ocs_isns_log(iscsi->os, "10- iSCSI name alias added, current_ptr moved %d bytes\n",
                 bytes_added);
    }
    /* end of the initiator part */

    payload_len = current_ptr - msg_ptr - sizeof(isns_hdr_t);
    msg_len = payload_len + sizeof(isns_hdr_t);
    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "payload_len= %u, msg_len= %u\n", payload_len, msg_len);

    //0- build and add the header of the RegDevMsg
    bytes_added = ocs_build_hdr_dev_attr_reg(msg_ptr, (uint16_t) payload_len);
    if (bytes_added != 12) {
        ocs_log_test(iscsi->os, "ERROR: ISNS  error in building the header of the message\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -2;
    }
    ocs_isns_log(iscsi->os , "size of header is: %d\n", (int) sizeof(isns_hdr_t) );
    ocs_isns_log(iscsi->os, "\t\t\tI WILL SEND NOW!\n");
    rc = ocs_iscsi_isns_send(ocs, isns_ip,
                 3205, //tcp port
                 msg_ptr,
                 &msg_len,
                 PDU_MEM_SIZE);

    if (rc == 0) {
        ocs_isns_log(ocs, "iSNS Send Sent, received %d bytes\n", msg_len);
        if (msg_len > 0) {
            if( ocs_parse_msg_rsp(&ocs->iscsi, __func__, msg_ptr, msg_len, &reg_period, eid) != 0) {
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -3;
            }
        }
    } else {
        ocs_log_test(ocs, "iSNS Send failed with rc %d\n", rc);
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -4;
    }
    if(ISNS_ENABLE_ESI == 0) {
        cycle_period = (reg_period * 3 / 4) * 1000;
        iscsi->isns_ip = *isns_ip;
        iscsi->isns_reg_period = cycle_period;

        /* use this defined constant to fix the period for testing */
        // cycle_period = ISNS_KEEP_ALIVE_TIMER_PERIOD * 1000;

        ocs_print_nl(iscsi, 3);
        ocs_isns_log(ocs, "ESI NOT ENABLED--> will call ocs_isns_keep_alive with cycle_period = %u msec\n", cycle_period);
        ocs_setup_timer(ocs, &iscsi->isns_timer,
                ocs_isns_keep_alive,
                ocs,
                cycle_period, false);
    } else {
        ocs_isns_log(ocs, "ESI IS ENABLED\n");
    }

    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tEND OF ISNS FUNCTION\n");
    ocs_isns_log(iscsi->os, "==============================================================================\n");

    return 0;
}


/**
 * @ingroup isns
 * @brief Sends the DevDereg message to the iSNS server.
 *
 * This function will de-register all targets in this iSCSI device with
 * within the same entity in the isns server.
 *
 * @param ocs Pointer to the ocs structure that represents this device
 * @param isns_ip to the IP addresses of the iSNS server
 * @param eid The entity ID assigned by the iSNS server during registration
 *
 * @return returns zero if successful, negative otherwise
 */
int8_t
ocs_isns_deregister(ocs_t *ocs, ocs_ip_address_t *isns_ip, char * eid)
{
    void *msg_ptr = NULL;
    void *current_ptr = NULL;
    char *iscsi_name;
    int bytes_added = 0;
    uint32_t payload_len = 0;
    int32_t rc;
    uint32_t msg_len;
    uint32_t index = 0;
    uint32_t reg_period = 0;
    ocs_iscsi_t *iscsi = NULL;

    if (ocs == NULL) {
        ocs_log_err(iscsi->os, "iSNS ERROR: ocs is null. Deregistration failed!\n");
        return -1;
    }

    iscsi = &ocs->iscsi;
    ocs_print_nl(&ocs->iscsi, 10);
    iscsi_name = ocs_iscsi_tgt_get_names(ocs, index);
    ocs_isns_log(ocs, "ISNS deregister begin\n");

    ocs_print_nl(&ocs->iscsi, 2);
    if (isns_ip == NULL) {
        ocs_log_err(iscsi->os, "iSNS ERROR: isns_ip is null. Deregistration failed!\n");
        return -1;
    }

    msg_ptr = ocs_malloc(ocs, PDU_MEM_SIZE, OCS_M_ZERO | OCS_M_NOWAIT);
    if (msg_ptr == NULL) {
        ocs_log_err(iscsi->os, "iSNS ERROR: Failed to allocate memory for msg_ptr\n");
        return -1;
    }
    current_ptr = msg_ptr + sizeof(isns_hdr_t);

    ocs_isns_log(iscsi->os, "\t\t\tSTART OF ISNS tgts part\n");
    ocs_print_nl(&ocs->iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tForming the PDU (adding tlv attrs)\n");
    ocs_print_nl(&ocs->iscsi, 2);
    //1-src attr =iscsi name
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ISCSI_NAME, ocs_strlen(iscsi_name),
                  iscsi_name, PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -1;
    }
    current_ptr += bytes_added;
    ocs_isns_log(ocs, "iscsi_name = (%s) size = %d\n", iscsi_name, (int) ocs_strlen(iscsi_name));
    ocs_isns_log(iscsi->os, " - iSCSI name added, current_ptr moved %d bytes\n",
             bytes_added);

    //2- delimiter
    bytes_added = ocs_add_delimiter(current_ptr,  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -1;
    }
    current_ptr += bytes_added;
    ocs_isns_log(iscsi->os, " - delimiter added, current_ptr moved %d bytes\n",
             bytes_added);


    // EID
    bytes_added = ocs_add_tlv(&ocs->iscsi, current_ptr, ISNS_TAG_ENTITY_IDENTIFIER, ocs_strlen(eid), eid,
                  PDU_MEM_SIZE - (msg_ptr - current_ptr) );
    if (bytes_added <= 0) {
        ocs_log_test(iscsi->os, "Error: Insufficient Space for the PDU Attributes\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -1;
    }
    current_ptr += bytes_added;
    ocs_isns_log(ocs, "eid = (%s) size = %d\n", eid, (int) ocs_strlen(eid));
    ocs_isns_log(iscsi->os, " - EID, current_ptr moved %d bytes\n",
             bytes_added);


    payload_len = current_ptr - msg_ptr - sizeof(isns_hdr_t);
    msg_len = payload_len + sizeof(isns_hdr_t);
    ocs_print_nl(iscsi, 1);
    ocs_isns_log(iscsi->os, "payload_len= %u, msg_len= %u\n", payload_len, msg_len);

    //0- build and add the header of the RegDevMsg
    bytes_added = ocs_build_hdr_dev_dereg(msg_ptr, (uint16_t) payload_len);
    if (bytes_added != 12) {
        ocs_log_test(iscsi->os, "ERROR: ISNS  error in building the header of the message\n");
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -2;
    }
    ocs_isns_log(iscsi->os , "size of header is: %d\n", (int) sizeof(isns_hdr_t) );

    ocs_isns_log(iscsi->os, "\t\t\tI WILL SEND NOW!\n");
    rc = ocs_iscsi_isns_send(ocs, isns_ip,
                 3205, //tcp port
                 msg_ptr,
                 &msg_len,
                 PDU_MEM_SIZE);

    if (rc == 0) {
        ocs_isns_log(ocs, "iSNS Send Sent, received %d bytes\n", msg_len);
        if (msg_len > 0) {
            if( ocs_parse_msg_rsp(&ocs->iscsi, __func__, msg_ptr, msg_len, &reg_period, eid) != 0) {
                ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
                return -3;
            }
        }
    } else {
        ocs_log_test(ocs, "iSNS Send failed with rc %d\n", rc);
        ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
        return -4;
    }
    ocs_free(iscsi->os, msg_ptr, PDU_MEM_SIZE);
    ocs_print_nl(iscsi, 2);
    ocs_isns_log(iscsi->os, "\t\t\tEND OF ISNS FUNCTION\n");
    ocs_isns_log(iscsi->os, "==============================================================================\n");

    return 0;
}