text: #include <stdio.h>
  #include <string.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <errno.h>
  //#include <stdint.h>
  #include <sys/ioctl.h>
  #include <sys/mman.h>
  #include "ionutils.h"
  #include "ipcsocket.h"
  
  
  void write_buffer(void *buffer, unsigned long len)
  {
  	int i;
  	unsigned char *ptr = (unsigned char *)buffer;
  
  	if (!ptr) {
  		fprintf(stderr, "<%s>: Invalid buffer...\n", __func__);
  		return;
  	}
  
  	printf("Fill buffer content:\n");
  	memset(ptr, 0xfd, len);
  	for (i = 0; i < len; i++)
  		printf("0x%x ", ptr[i]);
  	printf("\n");
  }
  
  void read_buffer(void *buffer, unsigned long len)
  {
  	int i;
  	unsigned char *ptr = (unsigned char *)buffer;
  
  	if (!ptr) {
  		fprintf(stderr, "<%s>: Invalid buffer...\n", __func__);
  		return;
  	}
  
  	printf("Read buffer content:\n");
  	for (i = 0; i < len; i++)
  		printf("0x%x ", ptr[i]);
  	printf("\n");
  }
  
  int ion_export_buffer_fd(struct ion_buffer_info *ion_info)
  {
  	int i, ret, ionfd, buffer_fd;
  	unsigned int heap_id;
  	unsigned long maplen;
  	unsigned char *map_buffer;
  	struct ion_allocation_data alloc_data;
  	struct ion_heap_query query;
  	struct ion_heap_data heap_data[MAX_HEAP_COUNT];
  
  	if (!ion_info) {
  		fprintf(stderr, "<%s>: Invalid ion info\n", __func__);
  		return -1;
  	}
  
  	/* Create an ION client */
  	ionfd = open(ION_DEVICE, O_RDWR);
  	if (ionfd < 0) {
  		fprintf(stderr, "<%s>: Failed to open ion client: %s\n",
  			__func__, strerror(errno));
  		return -1;
  	}
  
  	memset(&query, 0, sizeof(query));
  	query.cnt = MAX_HEAP_COUNT;
  	query.heaps = (unsigned long int)&heap_data[0];
  	/* Query ION heap_id_mask from ION heap */
  	ret = ioctl(ionfd, ION_IOC_HEAP_QUERY, &query);
  	if (ret < 0) {
  		fprintf(stderr, "<%s>: Failed: ION_IOC_HEAP_QUERY: %s\n",
  			__func__, strerror(errno));
  		goto err_query;
  	}
  
  	heap_id = MAX_HEAP_COUNT + 1;
  	for (i = 0; i < query.cnt; i++) {
  		if (heap_data[i].type == ion_info->heap_type) {
  			heap_id = heap_data[i].heap_id;
  			break;
  		}
  	}
  
  	if (heap_id > MAX_HEAP_COUNT) {
  		fprintf(stderr, "<%s>: ERROR: heap type does not exists\n",
  			__func__);
  		goto err_heap;
  	}
  
  	alloc_data.len = ion_info->heap_size;
  	alloc_data.heap_id_mask = 1 << heap_id;
  	alloc_data.flags = ion_info->flag_type;
  
  	/* Allocate memory for this ION client as per heap_type */
  	ret = ioctl(ionfd, ION_IOC_ALLOC, &alloc_data);
  	if (ret < 0) {
  		fprintf(stderr, "<%s>: Failed: ION_IOC_ALLOC: %s\n",
  			__func__, strerror(errno));
  		goto err_alloc;
  	}
  
  	/* This will return a valid buffer fd */
  	buffer_fd = alloc_data.fd;
  	maplen = alloc_data.len;
  
  	if (buffer_fd < 0 || maplen <= 0) {
  		fprintf(stderr, "<%s>: Invalid map data, fd: %d, len: %ld\n",
  			__func__, buffer_fd, maplen);
  		goto err_fd_data;
  	}
  
  	/* Create memory mapped buffer for the buffer fd */
  	map_buffer = (unsigned char *)mmap(NULL, maplen, PROT_READ|PROT_WRITE,
  			MAP_SHARED, buffer_fd, 0);
  	if (map_buffer == MAP_FAILED) {
  		fprintf(stderr, "<%s>: Failed: mmap: %s\n",
  			__func__, strerror(errno));
  		goto err_mmap;
  	}
  
  	ion_info->ionfd = ionfd;
  	ion_info->buffd = buffer_fd;
  	ion_info->buffer = map_buffer;
  	ion_info->buflen = maplen;
  
  	return 0;
  
  	munmap(map_buffer, maplen);
  
  err_fd_data:
  err_mmap:
  	/* in case of error: close the buffer fd */
  	if (buffer_fd)
  		close(buffer_fd);
  
  err_query:
  err_heap:
  err_alloc:
  	/* In case of error: close the ion client fd */
  	if (ionfd)
  		close(ionfd);
  
  	return -1;
  }
  
  int ion_import_buffer_fd(struct ion_buffer_info *ion_info)
  {
  	int buffd;
  	unsigned char *map_buf;
  	unsigned long map_len;
  
  	if (!ion_info) {
  		fprintf(stderr, "<%s>: Invalid ion info\n", __func__);
  		return -1;
  	}
  
  	map_len = ion_info->buflen;
  	buffd = ion_info->buffd;
  
  	if (buffd < 0 || map_len <= 0) {
  		fprintf(stderr, "<%s>: Invalid map data, fd: %d, len: %ld\n",
  			__func__, buffd, map_len);
  		goto err_buffd;
  	}
  
  	map_buf = (unsigned char *)mmap(NULL, map_len, PROT_READ|PROT_WRITE,
  			MAP_SHARED, buffd, 0);
  	if (map_buf == MAP_FAILED) {
  		printf("<%s>: Failed - mmap: %s\n",
  			__func__, strerror(errno));
  		goto err_mmap;
  	}
  
  	ion_info->buffer = map_buf;
  	ion_info->buflen = map_len;
  
  	return 0;
  
  err_mmap:
  	if (buffd)
  		close(buffd);
  
  err_buffd:
  	return -1;
  }
  
  void ion_close_buffer_fd(struct ion_buffer_info *ion_info)
  {
  	if (ion_info) {
  		/* unmap the buffer properly in the end */
  		munmap(ion_info->buffer, ion_info->buflen);
  		/* close the buffer fd */
  		if (ion_info->buffd > 0)
  			close(ion_info->buffd);
  		/* Finally, close the client fd */
  		if (ion_info->ionfd > 0)
  			close(ion_info->ionfd);
  	}
  }
  
  int socket_send_fd(struct socket_info *info)
  {
  	int status;
  	int fd, sockfd;
  	struct socketdata skdata;
  
  	if (!info) {
  		fprintf(stderr, "<%s>: Invalid socket info\n", __func__);
  		return -1;
  	}
  
  	sockfd = info->sockfd;
  	fd = info->datafd;
  	memset(&skdata, 0, sizeof(skdata));
  	skdata.data = fd;
  	skdata.len = sizeof(skdata.data);
  	status = sendtosocket(sockfd, &skdata);
  	if (status < 0) {
  		fprintf(stderr, "<%s>: Failed: sendtosocket\n", __func__);
  		return -1;
  	}
  
  	return 0;
  }
  
  int socket_receive_fd(struct socket_info *info)
  {
  	int status;
  	int fd, sockfd;
  	struct socketdata skdata;
  
  	if (!info) {
  		fprintf(stderr, "<%s>: Invalid socket info\n", __func__);
  		return -1;
  	}
  
  	sockfd = info->sockfd;
  	memset(&skdata, 0, sizeof(skdata));
  	status = receivefromsocket(sockfd, &skdata);
  	if (status < 0) {
  		fprintf(stderr, "<%s>: Failed: receivefromsocket\n", __func__);
  		return -1;
  	}
  
  	fd = (int)skdata.data;
  	info->datafd = fd;
  
  	return status;
  }
  