void getPath()
{
int i, start = 0,j,k;
int length = 0;
char* ppath = getenv("PATH");
int path_length = strlen(ppath);
for (i=0;i<path_length;i++) {
if (ppath[i] == ':') {
Node* node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault"); exit(1); }
k = 0;
for (j=start;j<i;j++) {
node->data[k] = ppath[j];
k++;
}
node->data[k] = '\0';
length = 0;
start = i + 1;
} else length++;
}
Node* node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault"); exit(1); }
k = 0;
for (j=start;j<path_length;j++) { //on traite le dernier path
node->data[k] = ppath[j];
k++;
}
node->data[k] = '\0';
flag_path = true;
if (DEBUG) print_list(&paths);
}
int iscsi_target_add_lu(
struct iscsi_target *target,
uint64 lun,
char *pathname,
enum volume_type type,
uint64 capacity,
uint32 sector_size,
char *pathname_iotrace,
void *data)
{
struct volume *vol;
int rv;
vol = vol_create(target, lun, pathname, type, capacity, sector_size, pathname_iotrace, data);
if (vol == NULL) {
goto failure;
}
log_dbg1("Initialized LU %llu in target \"%s\".\n",
lun, target->name);
rv = vol_run(vol);
if (rv) {
ASSERT((0), "NOT IMPLEMENTED YET\n");
}
list_add_elem(&(target->list_vol), &(vol->listelem));
log_dbg3("target->list_vol.len = "U32_FMT"\n", target->list_vol.len);
return 0;
failure:
return -1;
} // iscsi_target_add_lu
/**
* Create iSCSI task
* This function doesn't create iSCSI PDUs.
*/
struct iscsi_task *iscsi_create_task(struct iscsi_conn *conn, uint32 itt)
{
struct iscsi_task *task;
task = malloc_safe(sizeof(struct iscsi_task));
if (task == NULL) {
log_err("Unable to allocate memory (struct iscsi_task).\n");
}
// initialize
task->conn = conn;
task->itt = itt;
list_init(&(task->list_pdu));
list_init(&(task->list_page));
task->page_totallen = 0;
task->page_filled = 0;
task->vol = NULL;
task->ttt = 0xFFFFFFFF;
task->datasn = 0;
task->laptime.scsi_opcode = 0x00;
listelem_init(&(task->listelem), task);
list_add_elem(&(conn->list_task), &(task->listelem));
log_dbg3("Created iSCSI task (itt=0x%08lX, conn->list_task.len="U32_FMT").\n",
task->itt, conn->list_task.len);
return task;
} // iscsi_create_task
static inline void
histogram_add (DespeckleHistogram *hist,
guchar val,
const guchar *orig)
{
hist->elems[val]++;
list_add_elem (&hist->origs[val], orig);
}
void* list_add_unique_elem(LIST *list, void *data, BOOL(*cmp_fn)(void*, void*)){
int i;
void *exist_data;
for(i = 0; i < list->used_len; i++){
exist_data = list_get_elem_by_idx(list, i);
if(cmp_fn(exist_data, data)) return NULL;
}
return list_add_elem(list, data);
}
int main()
{
linkedlist list = create_list();
init_list(list);
list->next = malloc(sizeof(struct node));
list->next->elem = 0;
list->next->next = NULL;
list_add_elem(list, list->next, 1);
list_add_elem(list, list->next, 2);
list_add_elem(list, list->next, 3);
position result = find(list, 3);
if (result != NULL)
printf("find it: %d\n", result->elem);
result = find(list, 5);
if (result != NULL)
printf("find it: %d\n", result->elem);
list_print_all(list);
}
tree_node_t *tree_add_elem(tree_node_t *root_node, void *data, int(cmp_func)(void*,void*,void*), void *cmp_data)
{
tree_node_t *old_node_ptr=root_node;
tree_node_t *node_ptr=root_node;
int i;
while(node_ptr!=NULL)
{
if((i=cmp_func(data,node_ptr->list->data,cmp_data))>0)
{
old_node_ptr=node_ptr;
node_ptr=node_ptr->left;
}
else if(i<0)
{
old_node_ptr=node_ptr;
node_ptr=node_ptr->right;
}
else
{
node_ptr->list=list_add_elem(node_ptr->list, data);
return node_ptr;
}
}
node_ptr=calloc(1,sizeof(tree_node_t));
node_ptr->list=list_add_elem(NULL, data);
if(root_node!=NULL)
{
if(i>0)
{
old_node_ptr->left=node_ptr;
}
else
{
old_node_ptr->right=node_ptr;
}
}
return node_ptr;
}
/**
* Bind an iSCSI connection to an iSCSI session.
* (If an iSCSI session is not exist, create an iSCSI session)
*/
int iscsi_bind_connection(
const char *target_name,
union iscsi_sid sid,
struct iscsi_conn *conn)
{
struct iscsi_target *target = NULL;
struct iscsi_session *session = NULL;
int rv = 0;
ASSERT((conn != NULL), "conn == NULL\n");
ASSERT((conn->siso != NULL), "conn->siso == NULL\n");
ASSERT((conn->session == NULL), "conn->session != NULL\n");
ASSERT((conn->target == NULL), "conn->target != NULL\n");
log_dbg1("target_name=%s\n", target_name);
target = siso_lookup_target(conn->siso, target_name);
if (target == NULL) {
return -ENOENT;
}
conn->target = target;
LOCK_SESSIONS(target);
{
session = lookup_session(target, conn->sid);
if (conn->sid.id.tsih[0] == 0x00 || conn->sid.id.tsih[1] == 0x00) {
// Create session and attach connection to the session.
ASSERT((session == NULL), "session != NULL\n");
log_dbg1("create iscsi session\n");
session = iscsi_create_session(target, sid, conn);
if (session == NULL) {
rv = -ENOMEM;
goto done;
}
log_dbg1("conn->session=%p\n", conn->session);
// Enlink this iSCSI session to iSCSI session list.
list_add_elem(&(target->list_session), &(session->listelem));
} else {
// Current implementation doesn't support multi-connection.
log_err("Current implementation doesn't support multi-connection.\n");
rv = -EINVAL;
}
}
done:
UNLOCK_SESSIONS(target);
if (!rv) {
// detach iSCSI connection from tempolary list.
siso_detach_connection(conn->siso, conn);
}
return rv;
} // iscsi_bind_connection
/* Non utilisee */
void addPath(char *new_path, List *list)
{
int length = strlen(new_path);
printf("%d\n",length);
Node* node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault\n"); exit(1); }
node->data = ".\0";
if (DEBUG) print_list(&paths);
}
/**
* Create an iSCSI session and bind an iSCSI connection.
*/
struct iscsi_session *iscsi_create_session(
struct iscsi_target *target,
union iscsi_sid sid,
struct iscsi_conn *conn)
{
ASSERT((target != NULL), "target == NULL\n");
ASSERT((conn != NULL), "conn == NULL\n");
struct iscsi_session *session;
uint16 tsih;
session = malloc_safe(sizeof(struct iscsi_session));
if (session == NULL) {
goto failure;
}
listelem_init(&(session->listelem), session);
list_init(&(session->list_conn));
pthread_mutex_init(&(session->lock_list_conn), NULL);
session->target = target;
// Get TSIH and set.
ASSERT((conn->sid.id.tsih[0] == 0x00 && conn->sid.id.tsih[1] == 0x00),
"conn->sid.id.tsih[0] != 0x00 || conn->sid.id.tsih[1] != 0x00\n");
ASSERT((target->siso != NULL), "target->siso == NULL\n");
conn->sid.id64 = sid.id64;
tsih = siso_get_tsih(target->siso);
log_dbg1("tsih=0x%04X\n", tsih);
conn->sid.id.tsih[0] = (tsih >> 8);
conn->sid.id.tsih[1] = (tsih & 0xFF);
session->sid = conn->sid;
LOCK_CONNS(session);
{
// enlist iSCSI connection to this iSCSI session.
list_add_elem(&(session->list_conn), &(conn->listelem_session));
}
UNLOCK_CONNS(session);
conn->session = session;
return session;
failure:
return NULL;
} // iscsi_create_session
/*
* add PDU to task.
*/
int iscsi_add_pdu_to_task(struct iscsi_conn *conn, struct iscsi_task *task, struct iscsi_pdu *pdu)
{
pdu->task = task;
list_add_elem(&(task->list_pdu), &(pdu->listelem_task));
log_dbg3("-----\n");
log_dbg3("Add PDU (pdu->{opcode=0x%02X, itt=0x%08lX}, task->list_pdu.len="U32_FMT").\n",
pdu->opcode, pdu->itt, task->list_pdu.len);
do_each_list_elem(struct iscsi_pdu *, &(task->list_pdu), pdu, listelem_task) {
log_dbg3("&(pdu->listelem_task) = %p\n", &(pdu->listelem_task));
log_dbg3("pdu->listelem_task.next = %p\n", pdu->listelem_task.next);
log_dbg3("pdu->listelem_task.prev = %p\n", pdu->listelem_task.prev);
log_dbg3("pdu->listelem_task.body = %p\n", pdu->listelem_task.body);
ASSERT((pdu->listelem_task.next != NULL), "pdu->listelem_task.next == NULL\n");
ASSERT((pdu->listelem_task.prev != NULL), "pdu->listelem_task.prev == NULL\n");
iscsi_dump_pdu(conn, pdu);
} while_each_list_elem(struct iscsi_pdu *, &(task->list_pdu), pdu, listelem_task);
log_dbg3("-----\n");
return 0;
} // iscsi_add_pdu_to_task
void* stack_push(STACK *stack, void *data){
return list_add_elem((LIST*)stack, data);
}
void changePath(char *ppath)
{
int start = 5,i,j,k;
int length = 0;
int path_length = strlen(ppath);
Node* node;
if(flag_path == true && paths.begin != NULL) freeList(&paths);
for (i=5;i<path_length;i++) {
if (i == path_length-1 && ppath[i] == ':') {
node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault\n"); exit(1); }
k = 0;
for (j=start;j<i;j++) {
node->data[k] = ppath[j];
k++;
}
node->data[k] = '\0';
length = 0;
start = i + 1;
node = list_add_elem(&paths);
node->data = malloc((2)*sizeof(char));
node->data[0] = '.';
node->data[1] = '\0';
}
else if (ppath[i] == ':') {
node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault\n"); exit(1); }
k = 0;
for (j=start;j<i;j++) {
node->data[k] = ppath[j];
k++;
}
node->data[k] = '\0';
length = 0;
start = i + 1;
}
else length++;
}
if (ppath[path_length-1] != ':') {
node = list_add_elem(&paths);
node->data = malloc((length+1)*sizeof(char));
if (node->data == NULL) { printf("Memory fault\n"); exit(1); }
k = 0;
for (j=start;j<path_length;j++) { //on traite le dernier path
node->data[k] = ppath[j];
k++;
}
node->data[k] = '\0';
}
flag_path_change = true;
if (DEBUG) print_list(&paths);
}
void list_add_pointer(LIST_TP list, void* pointer_add) {
LIST_ELEM_TP elem_add = (LIST_ELEM_TP) malloc(sizeof(LIST_ELEM_T));
elem_add->int_elem = -1;
elem_add->pointer_elem = pointer_add;
list_add_elem(list, elem_add);
}
void list_add_int(LIST_TP list, int int_add) {
LIST_ELEM_TP elem_add = (LIST_ELEM_TP) malloc(sizeof(LIST_ELEM_T));
elem_add->int_elem = int_add;
elem_add->pointer_elem = NULL;
list_add_elem(list, elem_add);
}
