STGT:target userspace utils

// tgt.h
#ifndef __TGT_H__
#define __TGT_H__

#include <inttypes.h>
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

#define TGT_IPC_ADDR  "/var/run/tgtd.ipc_abstract_namespace"

static int control_port=0; 	//defualt=3260 

enum tgtadm_op {
	OP_NEW,   	//--op new
	OP_DELETE, 	//--op delete
	OP_SHOW, 	//--op show
	OP_BIND, 	//--op bind
	OP_UNBIND, 	//--op unbind
	OP_UPDATE, 	//--op update
	OP_STATS, 	//--op stat
	OP_START, 	//--op start
	OP_STOP, 	//--op stop
};
enum tgtadm_mode {
	MODE_SYSTEM, 	// --mode system
	MODE_TARGET, 	// --mode target
	MODE_DEVICE, 	// --mode logicalunit
	MODE_PORTAL, 	// --mode portal
	MODE_LLD, 		// --mode lld 

	MODE_SESSION, 	//--mode session
	MODE_CONNECTION,//--mode connection
	MODE_ACCOUNT, 	//--mode account
};
enum tgtadm_errno {
	TGTADM_SUCCESS,
	TGTADM_UNKNOWN_ERR,
	TGTADM_NOMEM,
	TGTADM_NO_DRIVER,
	TGTADM_NO_TARGET,

	TGTADM_NO_LUN,
	TGTADM_NO_SESSION,
	TGTADM_NO_CONNECTION,
	TGTADM_NO_BINDING,
	TGTADM_TARGET_EXIST,
	TGTADM_LUN_EXIST,
	TGTADM_BINDING_EXIST,

	TGTADM_ACL_EXIST,
	TGTADM_ACL_NOEXIST,
	TGTADM_USER_EXIST,
	TGTADM_NO_USER,
	TGTADM_TOO_MANY_USER,
	TGTADM_INVALID_REQUEST,

	TGTADM_OUTACCOUNT_EXIST,
	TGTADM_TARGET_ACTIVE,
	TGTADM_LUN_ACTIVE,
	TGTADM_DRIVER_ACTIVE,
	TGTADM_UNSUPPORTED_OPERATION,
	TGTADM_UNKNOWN_PARAM,

	TGTADM_PREVENT_REMOVAL,
};
typedef enum tgtadm_errno tgtadm_err;

struct tgtadm_req {
	enum tgtadm_mode mode;
	enum tgtadm_op op;
	char lld[64];
	uint32_t len;
	int32_t tid;
	uint64_t sid;
	uint64_t lun;
	uint32_t cid;
	uint32_t host_no;
	uint32_t device_type;
	uint32_t ac_dir;
	uint32_t pack;
	uint32_t force;
};
struct tgtadm_rsp {
	uint32_t err;
	uint32_t len;
};


struct concat_buf{
	FILE *streamf;
	int err;
	int used;
	char *buf;
	size_t size;
};

static const char *tgtadm_strerror(int err)
{
	static const struct {
		enum tgtadm_errno err;
		char *desc;
	} errors[] = {
	{ TGTADM_SUCCESS, "success" },
	{ TGTADM_UNKNOWN_ERR, "unknown error" },
	{ TGTADM_NOMEM, "out of memory" },
	{ TGTADM_NO_DRIVER, "can't find the driver" },
	{ TGTADM_NO_TARGET, "can't find the target" },
	{ TGTADM_NO_LUN, "can't find the logical unit" },
	{ TGTADM_NO_SESSION, "can't find the session" },
	{ TGTADM_NO_CONNECTION, "can't find the connection" },
	{ TGTADM_NO_BINDING, "can't find the binding" },
	{ TGTADM_TARGET_EXIST, "this target already exists" },
	{ TGTADM_BINDING_EXIST, "this binding already exists" },
	{ TGTADM_LUN_EXIST, "this logical unit number already exists" },
	{ TGTADM_ACL_EXIST, "this access control rule already exists" },
	{ TGTADM_ACL_NOEXIST, "this access control rule does not exist" },
	{ TGTADM_USER_EXIST, "this account already exists" },
	{ TGTADM_NO_USER, "can't find the account" },
	{ TGTADM_TOO_MANY_USER, "too many accounts" },
	{ TGTADM_INVALID_REQUEST, "invalid request" },
	{ TGTADM_OUTACCOUNT_EXIST, "this target already has an outgoing account" },
	{ TGTADM_TARGET_ACTIVE, "this target is still active" },
	{ TGTADM_LUN_ACTIVE, "this logical unit is still active" },
	{ TGTADM_DRIVER_ACTIVE, "this driver is busy" },
	{ TGTADM_UNSUPPORTED_OPERATION, "this operation isn't supported" },
	{ TGTADM_UNKNOWN_PARAM, "unknown parameter" },
	{ TGTADM_PREVENT_REMOVAL, "this device has Prevent Removal set" }
	};
	int i;
	for (i = 0; i < ARRAY_SIZE(errors); ++i)
		if (errors[i].err == err)
		return errors[i].desc;
		return "(unknown tgtadm_errno)";
}

#endif


//tgt.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include "tgt.h"

const char* LLD="iscsi";

void concat_buf_init(struct concat_buf *b){
	b->streamf=open_memstream(&b->buf,&b->size);
	b->err=b->streamf?0:errno;
	b->used=0;
}

int concat_printf(struct concat_buf *b,const char*format,...){
	va_list args;
	int nprinted;
	if(!b->err){
		va_start(args,format);
		nprinted=vfprintf(b->streamf,format,args);
		if(nprinted>=0)
			b->used += nprinted;
		else{
			b->err=nprinted;
			fclose(b->streamf);
			b->streamf =NULL;
		}
		va_end(args);
	}
	return b->err;
}

int concat_buf_finish(struct concat_buf *b){
	if(b->streamf){
		fclose(b->streamf);
		b->streamf=NULL;
		if(b->size)
			b->size++; 	//account for trailing NULL char
	}
	return b->err;
}

int concat_write(struct concat_buf *b, int fd, int offset)
{
	concat_buf_finish(b);
	if (b->err) {
		errno = b->err;
		return -1;
	}
	if (b->size - offset > 0)
	return write(fd, b->buf + offset, b->size - offset);
	else {
		errno = EINVAL;
		return -1;
	}
}

void concat_buf_release(struct concat_buf *b)
{
	concat_buf_finish(b);
	if (b->buf) {
		free(b->buf);
		memset(b, 0, sizeof(*b));
	}
}

int tgt_mgmt_connect(int *fd){
	int ret;
	struct sockaddr_un addr;
	char mgmt_path[256];
	*fd = socket(AF_LOCAL, SOCK_STREAM, 0);
	if (*fd < 0) {
		printf("can't create a socket!\n");
		return errno;
	}
	memset(&addr, 0, sizeof(addr));
	addr.sun_family = AF_LOCAL;
	sprintf(mgmt_path, "%s.%d", TGT_IPC_ADDR, control_port);
	strncpy(addr.sun_path, mgmt_path, sizeof(addr.sun_path));

	ret = connect(*fd, (struct sockaddr *) &addr, sizeof(addr));
	if (ret < 0)
		return errno;
	return 0;
}

int tgt_mgmt_rsp(int fd,struct tgtadm_req *req){
	struct tgtadm_rsp rsp;
	int ret,rest,len;
	retry:
	ret=recv(fd,&rsp,sizeof(rsp),MSG_WAITALL);
	if(ret<0){
		if(errno==EAGAIN) goto retry;
		else if(errno==EINTR)
			printf("interrupted by a signal!\n");
		else
			printf("can't get the response!\n");
		return errno;
	}else if(ret==0){
		printf("tgtd closed the socket!\n");
		return 0;
	}else if(ret!=sizeof(rsp)){
		printf("a partial response!\n");
		return 0;
	}

	if(rsp.err!=0){
		printf("%s!\n",tgtadm_strerror(rsp.err));
		return EINVAL;
	}

	rest=rsp.len-sizeof(rsp);
	if(!rest) return 0;

	while(rest){
		char buf[4096];
		memset(buf,0,sizeof(buf));
		len=sizeof(buf)-1;
		len=(len<rest?len:rest);
		ret=read(fd,buf,len);
		if(ret<=0){
			printf("\ncan't get the full response!\n");
			return errno;
		}
		fputs(buf,stdout);
		rest-=len;
	}
	return 0;
}

int tgt_mgmt_req(struct tgtadm_req *req,struct concat_buf*b){
	int ret,fd=0,done=0;
	req->len=sizeof(*req)+b->size;
	ret=tgt_mgmt_connect(&fd);
	if(ret<0){
		printf("can't connect to tgt daemon !\n");
		goto out;
	}
	ret=write(fd,req,sizeof(*req));
	if(ret<0||ret!=sizeof(*req)){
		printf("failed to send request hdr to tgt daemon!\n");
		ret=errno;
		goto out;
	}
	while(done<b->size){
		ret=concat_write(b,fd,done);
		if(ret>0)
			done+=ret;
		else if(errno!=EAGAIN){
			printf("failed to send request buf to tgt daemon!\n");
			ret=errno;
			goto out;
		}
	}
	printf("send to tgtd %d!\n",req->len);
	ret=tgt_mgmt_rsp(fd,req);
	out:
		if(fd>0) close(0);
		concat_buf_release(b);
		return ret;
}

int tgt_create_tgt(int tid,char *tgtname){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);//default
	req->mode=1; 		//MODE_TARGET
	req->op=0; 			//OP_NEW
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=-1; 		//default

	req->device_type=0; //default TYPE_DISK
	req->ac_dir=0;	//default 1=outgoing
	req->pack=0; 	//default
	req->force=0; 	//default 1=force
	concat_buf_init(&b);
	concat_printf(&b,"targetname=%s",tgtname);
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}
int tgt_delete_tgt(int tid){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);//default
	req->mode=1; 		//MODE_TARGET
	req->op=1; 			//OP_DELETE
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=-1; 		//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default

	concat_buf_init(&b);
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}
int tgt_add_lun(int tid,int lunid,char *lunname){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);//default
	req->mode=2; 		//MODE_DEVICE --mode logicalunit
	req->op=0; 			//OP_NEW
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=lunid;		//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default
	concat_buf_init(&b);
	concat_printf(&b,"path=%s",lunname);
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}
int tgt_del_lun(int tid,int lunid){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);//default
	req->mode=2; 		//MODE_DEVICE --mode logicalunit
	req->op=1; 			//OP_DELETE
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=lunid;		//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default
	concat_buf_init(&b);
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}
int tgt_bind_initiator(int tid,int type,char*init_name){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);//default
	req->mode=1; 		//MODE_TARGET
	req->op=3; 			//OP_BIND
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=-1; 		//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default
	concat_buf_init(&b);
	if(type==1){
		concat_printf(&b,"initiator-address=%s",init_name);
	}else if(type==0){
		concat_printf(&b,"initiator-name=%s",init_name);
	}else{
		printf("type error: \n");
	}
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}
int tgt_unbind_initiator(int tid,int type,char*init_name){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);	//default
	req->mode=1; 			//MODE_TARGET
	req->op=4; 				//OP_BIND
	req->tid=tid;
	req->sid=req->cid=req->host_no=0;//default
	req->lun=-1; 		//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default

	concat_buf_init(&b);
	if(type==1){
		concat_printf(&b,"initiator-address=%s",init_name);
	}else if(type==0){
		concat_printf(&b,"initiator-name=%s",init_name);
	}else{
		printf("type error: \n");
	}
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}

int tgt_show_tgt(int tid){
	struct tgtadm_req adm_req={0},*req=&adm_req;
	struct concat_buf b;
	int ret;
	strcpy(req->lld,LLD);	//default
	req->mode=1; 			//MODE_TARGET
	req->op=2; 				//OP_SHOW
	req->tid=tid?tid:-1;	// 0=ALL
	req->sid=req->cid=req->host_no=0;//default
	req->lun=-1; 			//default

	req->device_type=req->ac_dir=req->pack=req->force=0; //default

	concat_buf_init(&b);
	ret=concat_buf_finish(&b);
	if(ret){
		printf("failed to create request,errno:%d\n",ret);
		exit(ret);
	}
	ret=tgt_mgmt_req(req,&b);
	return ret;
}

int main(int argc,char*argv[]){
	  //tgt_show_tgt(0);
	//tgt_create_tgt(2,"guoming");
	//tgt_add_lun(2,1,"/dev/sdb3");
	//tgt_bind_initiator(1,1,"192.168.1.0/24");
	//tgt_unbind_initiator(1,1,"ALL");
	tgt_unbind_initiator(1,1,"192.168.1.180");
	tgt_bind_initiator(1,0,"cgm88s");
	//tgt_del_lun(2,1);
	//tgt_delete_tgt(2);
}