isns.c

iscsi企业级target.很好用

{
	struct isns_cmd *cmd;

	if (!(cmd = (struct isns_cmd*)malloc(sizeof(struct isns_cmd))))
		return NULL;
	if (!(cmd->pdu.hdr = (struct isns_hdr *)malloc(MAX_ISNS_CMD_SIZE))) {
		free(cmd);
		return NULL;
	}
	cmd->pdu.pay_load = (((char *)cmd->pdu.hdr) + ISNS_HDR_LEN);
	cmd->pdu.authentication_block = NULL;
	cmd->cmd_size = ISNS_HDR_LEN;

	return cmd;
}

void free_isns_cmd(struct isns_cmd *cmd)
{
	if (cmd->pdu.authentication_block)
		free(cmd->pdu.authentication_block);
	if (cmd->pdu.hdr)
		free(cmd->pdu.hdr);
	free(cmd);
}

struct isns_resp *allocate_isns_resp(void)
{
	struct isns_resp *resp;

	if (!(resp = (struct isns_resp*)malloc(sizeof(struct isns_resp))))
		return NULL;
	if (!(resp->pdu.hdr = (struct isns_hdr *)malloc(MAX_ISNS_RESP_SIZE))) {
		free(resp);
		return NULL;
	}
	resp->pdu.pay_load = (((char *)resp->pdu.hdr) + ISNS_HDR_LEN);
	resp->pdu.authentication_block = NULL;

	return resp;
}

void free_isns_resp(struct isns_resp *resp)
{
	if (resp->pdu.authentication_block)
		free(resp->pdu.authentication_block);
	if (resp->pdu.hdr)
		free(resp->pdu.hdr);
	free(resp);
}

void init_isns_hdr(struct isns_hdr *hdr, int function_id, int replace)
{
	hdr->isnsp_version = htons((u16)ISNSP_VERSION);
	hdr->function_id = htons((u16)function_id);
	hdr->pdu_length = 0;
	hdr->flags = 0;
	/* always use one PDU for one command we send */
	set_bit_first_pdu(hdr->flags);
	set_bit_last_pdu(hdr->flags);
	set_bit_sender_client(hdr->flags);
	if (replace)
		set_bit_replace(hdr->flags);
	hdr->flags = htons((u16)hdr->flags);
	get_next_transaction_id(&hdr->transaction_id);
	hdr->transaction_id = htons((u16)hdr->transaction_id);
	hdr->sequence_id = 0;
}

int check_isns_hdr(struct isns_hdr *hdr, int function_id)
{
	if (ntohs(hdr->isnsp_version) != ISNSP_VERSION)
		return -EINVAL;
	if (ntohs(hdr->function_id) != function_id)
		return -EINVAL;
	/* TODO: more check here */
	return 0;
}

int check_isns_resp_status(struct isns_pdu *pdu)
{
	int status = ntohl(*(u32 *)pdu->pay_load);

	log_debug(1, "return status code %d\n", status);
	return status;
}

/* DD related functions */
int RegDD(void)
{
	return -EPERM;
}

int DeRegDD(void)
{
	return -EPERM;
}

/* DDS related functions */
int RegDDS(void)
{
	return -EPERM;
}

int DeRegDDS(void)
{
	return -EPERM;
}

/* Entity related functions */
int RegEntity(void)
{
	return -EPERM;
}

int DeRegEntity(struct network_entity *entity, struct tag_len_val *name)
{
	struct isns_cmd *cmd;
	struct isns_pdu *pdu;
	struct isns_resp *resp = NULL;
	char *buf;

	if (!entity) {
		log_error("Null entity to deregister.\n");
		return -EINVAL;
	}

	if (!(cmd = allocate_isns_cmd())) {
		log_error("allocate isns cmd fail\n");
		return -ENOMEM;
	}
	pdu = &cmd->pdu;
	init_isns_hdr(pdu->hdr, FUNC_DevDeReg, NO_REPLACE);
	buf = pdu->pay_load;
	buf = append_tlv(buf, name);
	buf = append_tlv(buf, &delimiter);
	buf = append_tlv(buf, &entity->eid);

	cmd->cmd_size = buf - (char *)pdu->hdr;
	pdu->hdr->pdu_length = htons((u16)(buf - (char *)pdu->pay_load));

	if (send_cmd(cmd)) {
		log_error("fail to send isns cmd\n");
		return -EIO;
	}
	if (!(resp = allocate_isns_resp())) {
		log_error("allocate isns resp fail\n");
		return -ENOMEM;
	}
	recv_resp(resp, FUNC_DevDeRegRsp);
	free_isns_resp(resp);

	return 0;
}

int QryEntity(void)
{
	return -EPERM;
}

int UpdateEntity(void)
{
	return -EPERM;
}

/* Node related functions */
struct storage_node *initialize_storage_node(char *name, char* alias)
{
	struct storage_node *p;

	if (!(p = (struct storage_node *)malloc(sizeof(struct storage_node)))) {
		log_error("fail to get memory for storage node\n");
		return NULL;
	}
	init_storage_node(p);

	set_tlv_iscsi_name(&p->iscsi_name, name);
	set_tlv_iscsi_node_type(&p->iscsi_node_type, NODE_TYPE_TARGET);
	set_tlv_iscsi_alias(&p->iscsi_alias, alias);
	return p;
}

void cleanup_storage_node(struct storage_node *node)
{
	free(node);
}

int RegNode(struct storage_node *node)
{
	struct isns_cmd *cmd;
	struct isns_pdu *pdu;
	struct isns_resp *resp = NULL;
	char *buf;
	struct portal *p;

	if (!node) {
		log_error("Null storage node to register.\n");
		return -EINVAL;
	}
	if (!(cmd = allocate_isns_cmd())) {
		log_error("allocate isns cmd fail\n");
		return -ENOMEM;
	}
	pdu = &cmd->pdu;
	init_isns_hdr(pdu->hdr, FUNC_DevAttrReg, NO_REPLACE);
	buf = pdu->pay_load;
	buf = append_tlv(buf, &node->iscsi_name);
	buf = append_tlv(buf, &delimiter);
	/* FIXME: assume one entity now */
	buf = append_tlv(buf, &iet_entity->eid);
	buf = append_tlv(buf, &iet_entity->entity_proto);

	for (p = iet_portal; p ; p = p->next) {
		buf = append_tlv(buf, &p->portal_ip_addr);
		buf = append_tlv(buf, &p->portal_port);
	}
	buf = append_tlv(buf, &node->iscsi_name);
	buf = append_tlv(buf, &node->iscsi_node_type);
	buf = append_tlv(buf, &node->iscsi_alias);
	buf = append_tlv(buf, &node->iscsi_auth_method);

	cmd->cmd_size = buf - (char *)pdu->hdr;
	pdu->hdr->pdu_length = htons((u16)(buf - (char *)pdu->pay_load));

	if (send_cmd(cmd)) {
		log_error("fail to send isns cmd\n");
		free_isns_cmd(cmd);
		return -EIO;
	}
	free_isns_cmd(cmd);

	if (!(resp = allocate_isns_resp())) {
		log_error("allocate isns resp fail\n");
		return -ENOMEM;
	}
	if (recv_resp(resp, FUNC_DevAttrRegRsp)) {
		free_isns_resp(resp);
		return -EIO;
	}
	if ((ntohl(*((u32 *)resp->pdu.pay_load + 1)) == ATTR_TAG_EID) &&
					!iet_entity->eid.attr_len) {
		// get assigned EID from iSNS server
		iet_entity->eid.attr_len = ntohl(*((u32 *)resp->pdu.pay_load + 2));
		memcpy(iet_entity->eid.attr_val, resp->pdu.pay_load + 8,
					ntohl(*((u32 *)resp->pdu.pay_load + 2)));
		log_debug(1, "new eid info, %ld, %s\n", iet_entity->eid.attr_len,
					iet_entity->eid.attr_val);
	}
	free_isns_resp(resp);
	return 0;
}

int DeRegNode(struct storage_node *node)
{
	struct isns_cmd *cmd;
	struct isns_pdu *pdu;
	struct isns_resp *resp = NULL;
	char *buf;

	if (!node) {
		log_error("Null storage node to deregister.\n");
		return -EINVAL;
	}

	if (!(cmd = allocate_isns_cmd())) {
		log_error("allocate isns cmd fail\n");
		return -ENOMEM;
	}
	pdu = &cmd->pdu;
	init_isns_hdr(pdu->hdr, FUNC_DevDeReg, NO_REPLACE);
	buf = pdu->pay_load;
	buf = append_tlv(buf, &node->iscsi_name);
	buf = append_tlv(buf, &delimiter);
	/* iscsi name can be as an operating attr for dereg */
	//buf = append_tlv(buf, &iet_entity->eid);
	buf = append_tlv(buf, &node->iscsi_name);

	cmd->cmd_size = buf - (char *)pdu->hdr;
	pdu->hdr->pdu_length = htons((u16)(buf - (char *)pdu->pay_load));

	if (send_cmd(cmd)) {
		log_error("fail to send isns cmd\n");
		return -EIO;
	}
	if (!(resp = allocate_isns_resp())) {
		log_error("allocate isns resp fail\n");
		return -ENOMEM;
	}
	recv_resp(resp, FUNC_DevDeRegRsp);
	free_isns_resp(resp);

	return 0;
}

int QryNode(void)
{
	return -EPERM;
}

int UpdateNode(void)
{
	return -EPERM;
}

/* Portal related functions */
int RegPortal(void)
{
	return -EPERM;
}

int DeRegPortal(struct portal *p, struct tag_len_val *name)
{
	struct isns_cmd *cmd;
	struct isns_pdu *pdu;
	struct isns_resp *resp = NULL;
	char *buf;

	if (!p) {
		log_error("Null portal to deregister.\n");
		return -EINVAL;
	}

	if (!(cmd = allocate_isns_cmd())) {
		log_error("allocate isns cmd fail\n");
		return -ENOMEM;
	}
	pdu = &cmd->pdu;
	init_isns_hdr(pdu->hdr, FUNC_DevDeReg, NO_REPLACE);
	buf = pdu->pay_load;
	buf = append_tlv(buf, name);
	buf = append_tlv(buf, &delimiter);
	buf = append_tlv(buf, &p->portal_ip_addr);
	buf = append_tlv(buf, &p->portal_port);

	cmd->cmd_size = buf - (char *)pdu->hdr;
	pdu->hdr->pdu_length = htons((u16)(buf - (char *)pdu->pay_load));

	if (send_cmd(cmd)) {
		log_error("fail to send isns cmd\n");
		return -EIO;
	}
	if (!(resp = allocate_isns_resp())) {
		log_error("allocate isns resp fail\n");
		return -ENOMEM;
	}
	recv_resp(resp, FUNC_DevDeRegRsp);
	free_isns_resp(resp);

	return 0;
}

int QryPortal(void)
{
	return -EPERM;
}

int UpdatePortal(void)
{
	return -EPERM;
}