uint32_t version;

float env_temperature;
float env_moisture;

float soil_temperature;
float soil_moisture;

sec = msec/1000;
usec = (msec%1000)*1000L;

new_timerset.it_interval.tv_sec  =  sec;
new_timerset.it_interval.tv_usec = usec;

new_timerset.it_value.tv_sec  =  sec;
new_timerset.it_value.tv_usec = usec;

return setitimer(ITIMER_REAL,&new_timerset,NULL);

if(strlen(s) >= 25)
{
	if(s[17] >= 0x30 && s[17] <= 0x39 && s[18] >= 0x30 && s[18] <= 0x39 )
	{
		val = (s[17]-0x30)*10 + (s[18] - 0x30);
	}

}

return -1;

	time_t t = time(NULL);
	char* s = ctime(&t);
	int32_t val = get_sec_val(s);
	printf("sec is %d\n",val);
	printf("s len is %d\n",strlen(s));
	printf("send data\n");
	printf("time is %s\n",s);
	sleep(1);

}

}

return ((float)rand()/(float)(RAND_MAX)*n);

int i =0;
while(1)
{
	for(i=0; i< NUM_PLANT_POT; i++)
	{
		pp[i].version = 1;
		pp[i].env_temperature = 25.8;
		pp[i].env_moisture = 54.2;

		pp[i].soil_temperature = 25.9;
		pp[i].soil_moisture = 65.6;
	}

	sleep(10);

}

printf("sizeof double is %d\n",sizeof(double));
printf("sizeof float is %d\n",sizeof(float));
return 0;

pthread_t pth_send;
pthread_t pth_recv;
pthread_create(&pth_send,NULL,send_data,NULL);
pthread_create(&pth_recv,NULL,recv_data,NULL);
pthread_join(pth_send,NULL);
pthread_join(pth_recv,NULL);

return 0;



signal(SIGALRM,on_timer);
set_ticker(1000);
//sleep(8);

struct timeval tv;
tv.tv_sec =10; 
tv.tv_usec =0; 

fd_set rd;
FD_ZERO(&rd);
FD_SET(0,&rd);
select(1,&rd,NULL,NULL,&tv);
printf("to the end\n");


return 0;

int32_t i=0;
int32_t j=0;
uint8_t err = 0;

while(in_size)
{
	if(inbuf[i] == ' ')
	{
		++i;
		--in_size;
	}
	else
	{

		if(inbuf[i] >= '0' && inbuf[i] <= '9')
		{
			out_buf[j] = 16*(inbuf[i] - '0');
		}
		else if(inbuf[i] >= 'a' && inbuf[i] <= 'f')
		{
			out_buf[j] = 16*(10 + inbuf[i] - 'a');
		}
		else if(inbuf[i] >= 'A' && inbuf[i] <= 'F')
		{
			out_buf[j] = 16*(10 + inbuf[i] - 'A');
		}
		else
		{
			err = -1;
			break;
		}



		if(inbuf[i+1] >= '0' && inbuf[i+1] <= '9')
		{
			out_buf[j] += (inbuf[i+1] - '0');
		}
		else if(inbuf[i+1] >= 'a' && inbuf[i+1] <= 'f')
		{
			out_buf[j] += (10 + inbuf[i+1] - 'a');
		}
		else if(inbuf[i+1] >= 'A' && inbuf[i+1] <= 'F')
		{
			out_buf[j] += (10 + inbuf[i+1] - 'A');
		}
		else
		{
			err = -2;
			break;
		}

		i+=2;			
		++j;
		in_size -= 2;
	}

}

if(err < 0)
{
	return err;
}
else
{
	return j;
}

while((ret = read(fd,&ch,1)) == 1)
{
	if(ch == '\n')
	{
		break;
	}
	else
	{
		buffer[i] = ch;
	}

	++i;

	if(i >= size)
	{
		err = -1;
		break;
	}

}

if(err < 0)
{
	return err;
}
else
{
	if(ret <= 0)
	{
		printf("xxxxx ret is %d\n",ret);
		return ret;
	}
	else
	{
		printf("ooooo i is %d\n",i);
		return i;
	}
}

int32_t i = 0;
int32_t err = 0;
int8_t result = 0;

while(i < buf_size)
{
	if(buf[i] == tagh && buf[i+1] == tagl)
	{
		result = 1;
		break;
	}

	i++;
}

if(result && i < (buf_size -2))//the last 2 bytes could not be tagh an tagl
{
	return i;

}
else
{
	err = -1;
	return err;
}

int32_t len = buf[offset]*16 + buf[offset+1];
if(len + 2 + offset > buf_size)
{
	return -1;
}
else
{
	return len;
}

int offset_i = find_tag(tbuf,8,0x12,0x34);
printf("offset_i is %d\n",offset_i);

return (void*)0;



fd = open("./ifp_t.log",O_RDONLY);

if(fd < 0)
{
	perror("open failed\n");
	exit(EXIT_FAILURE);
}

//=====================================================

if(read(fd,raw_buffer,isize) != isize)
{
	perror("read error\n");
	exit(EXIT_FAILURE);
}

int32_t isize;
int32_t tsize;

memset(raw_buffer,0,128);

while((isize = read_one_line(fd,raw_buffer,128)) > 0)
{
	printf("it is %s\n",raw_buffer);

	printf("isize is %d\n",isize);
	tsize = byte_str_2_hex(raw_buffer,isize,m_buffer,128);
	printf("tsize is %d\n",tsize);
	for(int i=0;i< tsize; i++)
	{
		printf("byte is %02x\n",m_buffer[i]);
	}

	memset(raw_buffer,0,128);
	memset(m_buffer,0,128);
}



return (void*)0;

while(1)
{
	pthread_mutex_lock(&mutex1);

	printf("tha counter is %d\n",counter);

	if(counter == 10)
	{
		pthread_mutex_unlock(&mutex1);
		//exit(0);
		break;
	}
	else
	{
		counter++;
		pthread_mutex_unlock(&mutex1);
	}
}

return 0;

	pthread_mutex_unlock(&mutex1);
}

return 0;

pthread_create(&ifpr,NULL,ifp_read,NULL);
//	pthread_create(&ifpw,NULL,ifp_write,NULL);

pthread_join(ifpr,NULL);
//	pthread_join(ifpw,NULL);

return 0;

HD_UART_SUCCESS = 0,
HD_UART_COMM_ERROR, 
HD_UART_COMM_TIMEOUT,              
HD_UART_UNSUPPORTED_DEVICE,       
HD_UART_DEVICE_UNINITIALIZED,  
HD_UART_HW_ERROR,  
HD_UART_INVALID_PARAM,  
HD_UART_PARAM_OUT_OF_RANGE,   
HD_UART_INVALID_HANDLE,          
HD_UART_IRQ_PENDING,            
HD_UART_READ_STATUS_TIMEOUT,     
HD_UART_INVALID_POWER_STATE,   
HD_UART_HAL_INIT_ERROR,           
HD_UART_INSUFFICIENT_FIFO_SPACE,
HD_UART_CRC_ERROR,         
HD_UART_QUEUE_FULL,            
HD_UART_QUEUE_EMPTY,    
HD_UART_BUFFER_TOO_SMALL,
HD_UART_INVALID_PORT,  
HD_UART_ADDRESS_FILTER_TABLE_FULL, 
HD_UART_COMM_BUSY,   
HD_UART_ZERO_LENGTH_TRX,    
HD_UART_SW_RESET_TIMEOUT, 
HD_UART_NOT_IMPLEMENTED, 
HD_UART_NOT_IMPLEMENTED_SOFTWARE,
HD_UART_UNSUPPORTED_FEATURE,   
HD_UART_PLACEHOLDER_ERROR,   

// if NULL is given as format, close the opened file
if(format != NULL) {
  // increase length by 2 (for \n\0
  length = strlen(format) + 2;
  // allocate memory
  fformat = malloc(sizeof(char) * length);
  // copy the format over
  strncpy(fformat, format, length - 2);
  // append \n\0
  fformat[length - 2] = '\n';
  fformat[length - 1] = '\0';

  // get the rest of the arguments
  va_start(args, format);

  // use vfprintf() to 
  vfprintf(logfile, fformat, args); 
  // forces the logmessage to be written into the file right now
  fflush(logfile);
 
  va_end(args);

  // free the allocated memory for the format string
  free(fformat);
} 
else 
{
  // close the logfile
  fclose(logfile);
}

// select the first menu entry if enter is pressed
if(ch == '\n') ch = '1';
// a number pressed?
if(ch >= '0' && ch <= '9') {
  number = ch - '0';
  // prevent from handling numbers which are > than the number of menu entries
  if(ch - '0' <= lines) {
    // get out of the loop
    break;
  }
}

int fd_flags;

fcntl(0,F_SETOWN,getpid());
fd_flags = fcntl(0,F_GETFL);

fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

static char input[1];

kbcbuf.aio_fildes = 0;
kbcbuf.aio_buf = input;
kbcbuf.aio_nbytes = 1;
kbcbuf.aio_offset = 0;


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
kbcbuf.aio_sigevent.sigev_signo = SIGIO;

int c;
char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

if(aio_error(&kbcbuf) != 0)
{
	perror("reading failed");
}
else
{
	if(aio_return(&kbcbuf) == 1)
	{
		c=*cp;

		move(15,15);
		addch(c);
		refresh();

		if(c == 'q')
		{
			endwin();	
			printf("that is it\n");
			exit(EXIT_SUCCESS);

		}

	}

	aio_read(&kbcbuf);

}

gethostname(hname,sizeof(hname));
hent = gethostbyname(hname);

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{ 
	perror("socket creation failed"); 
	exit(EXIT_FAILURE); 
} 

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 
// Filling server information 
servaddr.sin_family    = AF_INET; // IPv4 
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 
//servaddr.sin_port = PORT; 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr,  
			sizeof(servaddr)) < 0 ) 
{ 
	perror("bind failed"); 
	exit(EXIT_FAILURE); 
} 

int len, n; 
len = sizeof(cliaddr);  //len is value/resuslt 



WINDOW *xw;
void on_input(int);
signal(SIGIO,on_input);
//enable_kbd_signals();

setup_aio_buffer();
aio_read(&kbcbuf);

init_curses();

while(1)
{
	//pause();
	move(20,25);
	//printf("waiting on port %d\n",PORT);
	printw("waiting on port %d\n",PORT);
	refresh();

	buffer[n] = '\0'; 
	//printf("Client : %s\n", buffer); 
	move(25,25);
	printw("Client : %s\n", buffer); 
	refresh();

	//sleep(5);
}
//	main_menu(); 
//	xw=create_dialog_window("hello"); 
//	wrefresh(xw);
//	refresh();

//	sleep(4);
end_curses();

// if NULL is given as format, close the opened file
if(format != NULL) {
  // increase length by 2 (for \n\0
  length = strlen(format) + 2;
  // allocate memory
  fformat = malloc(sizeof(char) * length);
  // copy the format over
  strncpy(fformat, format, length - 2);
  // append \n\0
  fformat[length - 2] = '\n';
  fformat[length - 1] = '\0';

  // get the rest of the arguments
  va_start(args, format);

  // use vfprintf() to 
  vfprintf(logfile, fformat, args); 
  // forces the logmessage to be written into the file right now
  fflush(logfile);
 
  va_end(args);

  // free the allocated memory for the format string
  free(fformat);
} else {
  // close the logfile
  fclose(logfile);
}

  logfile = fopen(name, "a");
  // if that doesn't work exit with an error message
  if(logfile == NULL)
  {
    //fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
    fprintf(stderr, "Cannot open logfile %s\n", name);
    exit(EXIT_FAILURE);
  }

  // increase length by 2 (for \n\0
  length = strlen(format) + 2;
  // allocate memory
  fformat = malloc(sizeof(char) * length);
  // copy the format over
  strncpy(fformat, format, length - 2);
  // append \n\0
  fformat[length - 2] = '\n';
  fformat[length - 1] = '\0';

  // get the rest of the arguments
  va_start(args, format);

  // use vfprintf() to 
  vfprintf(logfile, fformat, args); 
  // forces the logmessage to be written into the file right now
  fflush(logfile);
 
  va_end(args);

  // free the allocated memory for the format string
  free(fformat);
  fclose(logfile);

hlog("x.log","%d\t%s\n",93,"second");
hlog("x.log","%d\t%s\n",73,"third");

hlog("y.log","%d\t%s\n",33,"second");
hlog("y.log","%d\t%s\n",43,"third");

return 0;

uint32_t version;

float env_temperature;
float env_moisture;

float soil_temperature;
float soil_moisture;

sec = msec/1000;
usec = (msec%1000)*1000L;

new_timerset.it_interval.tv_sec  =  sec;
new_timerset.it_interval.tv_usec = usec;

new_timerset.it_value.tv_sec  =  sec;
new_timerset.it_value.tv_usec = usec;

return setitimer(ITIMER_REAL,&new_timerset,NULL);

if(strlen(s) >= 25)
{
	if(s[17] >= 0x30 && s[17] <= 0x39 && s[18] >= 0x30 && s[18] <= 0x39 )
	{
		val = (s[17]-0x30)*10 + (s[18] - 0x30);
	}

}

return -1;

	time_t t = time(NULL);
	char* s = ctime(&t);
	int32_t val = get_sec_val(s);
	printf("sec is %d\n",val);
	printf("s len is %d\n",strlen(s));
	printf("send data\n");
	printf("time is %s\n",s);
	sleep(1);

}

}

return ((float)rand()/(float)(RAND_MAX)*n);

int i =0;
while(1)
{
	for(i=0; i< NUM_PLANT_POT; i++)
	{
		pp[i].version = 1;
		pp[i].env_temperature = 25.8;
		pp[i].env_moisture = 54.2;

		pp[i].soil_temperature = 25.9;
		pp[i].soil_moisture = 65.6;
	}

	sleep(10);

}

printf("sizeof double is %d\n",sizeof(double));
printf("sizeof float is %d\n",sizeof(float));
return 0;

pthread_t pth_send;
pthread_t pth_recv;
pthread_create(&pth_send,NULL,send_data,NULL);
pthread_create(&pth_recv,NULL,recv_data,NULL);
pthread_join(pth_send,NULL);
pthread_join(pth_recv,NULL);

return 0;



signal(SIGALRM,on_timer);
set_ticker(1000);
//sleep(8);

struct timeval tv;
tv.tv_sec =10; 
tv.tv_usec =0; 

fd_set rd;
FD_ZERO(&rd);
FD_SET(0,&rd);
select(1,&rd,NULL,NULL,&tv);
printf("to the end\n");


return 0;

pTNODE node=(pTNODE)malloc(sizeof(TNODE));


if(node == NULL)
{
	perror("malloc failed!\n");
	exit(EXIT_FAILURE);
}

node->num = n;

if(root == NULL)
{
	node->next = NULL;
	root = node;
}
else
{
	 node->next = root;
	 root = node;
}


return root;

pTNODE temp = NULL; 
while(cur && cur->num != n )
{
	prev = cur;
	cur = cur->next;

}



if(cur == NULL)
{

	return root;
}



if(prev == NULL)
{
	temp = cur;
	root = root->next;

}
else if(cur->next == NULL)
{
	temp = cur;
	prev->next = NULL;


}
else
{

	temp = cur;

	prev->next = cur->next;

}

free(temp);

return root;

while(root)
{

	printf("%d\n",root->num);
	root = root->next;

}


return 0;

pTNODE root = NULL;



for(int m=0;m<8;m++)
{

	root = insert_tnode(root,m+1);
}

printf("========================\n");
tllist(root);



printf("========================\n");
root = delete_tnode(root,5);
tllist(root);

printf("========================\n");
root = delete_tnode(root,9);
tllist(root);

printf("========================\n");
root = delete_tnode(root,1);
tllist(root);

printf("========================\n");
root = delete_tnode(root,10);
tllist(root);
return 0;

return 0;

}

q->buf[q->tail] = n;
q->tail = (q->tail +1)%(qSize+1);

return 0;	

*val = q->buf[q->head];
q->head= (q->head +1)%(qSize+1);

return 0;	

uint32_t i;
for(i=0;i<len;i++)
{

	if(sArray[i] != dArray[i])
	{
		return -1;

	}

}

return 1;

srand(time(NULL));

uint32_t vlist[16]={0};

initQueue(&qa,myBuffer);

for(i=0;i<qSize;i++)
{
	vlist[i] = rand()%0xffff;
}


for(i=0;i<qSize;i++)
{
	enQueue(&qa,enlist[i]);
}

for(i=0;i<qSize;i++)
{
	deQueue(&qa,&delist[i]);
}


if(compareArray(enlist,delist,qSize) ==1)
{

	printf("success\n");

	return 0;

}
else
{

	printf("error\n");

	return -1;
}

return 0;

mcrypt_generic_init(td, key, key_len, IV);
mcrypt_generic(td, buffer, buffer_len);
mcrypt_generic_deinit (td);
mcrypt_module_close(td);

return 0;

mcrypt_generic_init(td, key, key_len, IV);
mdecrypt_generic(td, buffer, buffer_len);
mcrypt_generic_deinit (td);
mcrypt_module_close(td);

return 0;

mcrypt_generic_init(td, key, key_len, NULL);
mcrypt_generic(td, buffer, buffer_len);
mcrypt_generic_deinit (td);
mcrypt_module_close(td);

return 0;

buffer = calloc(1, buffer_len);
//strncpy(buffer, plaintext, buffer_len);
strncpy(buffer, plainAes128, buffer_len);

printf("==C==\n");
//printf("plain:   %s\n", plaintext);

printf("cipher:  "); display(buffer , buffer_len);
//decrypt(buffer, buffer_len, IV, key, keysize);
//printf("decrypt: %s\n", buffer);

return 0;

// if NULL is given as format, close the opened file
if(format != NULL) {
  // increase length by 2 (for \n\0
  length = strlen(format) + 2;
  // allocate memory
  fformat = malloc(sizeof(char) * length);
  // copy the format over
  strncpy(fformat, format, length - 2);
  // append \n\0
  fformat[length - 2] = '\n';
  fformat[length - 1] = '\0';

  // get the rest of the arguments
  va_start(args, format);

  // use vfprintf() to 
  vfprintf(logfile, fformat, args); 
  // forces the logmessage to be written into the file right now
  fflush(logfile);
 
  va_end(args);

  // free the allocated memory for the format string
  free(fformat);
} else {
  // close the logfile
  fclose(logfile);
}

glog("%d\t%s\n",93,"second");
glog("%d\t%s\n",73,"third");
glog("%s\t%s\n","string-A","string-B");
glog("%s\t%f\n","string-C",3.1415);


printf("done\r\n");

return 0;

if(!(format == NULL && logfile == NULL)) {
	// open the logfile if not already opened
	if(logfile == NULL) {
		logfile = fopen(LOG_FILE, "w");
		// if that doesn't work exit with an error message
		if(logfile == NULL) {
			fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
			exit(EXIT_FAILURE);
		}
	}

	// if NULL is given as format, close the opened file
	if(format != NULL) {
		// increase length by 2 (for \n\0
		length = strlen(format) + 2;
		// allocate memory
		fformat = malloc(sizeof(char) * length);
		// copy the format over
		strncpy(fformat, format, length - 2);
		// append \n\0
		//fformat[length - 2] = '\n';
		fformat[length - 2] = '\0';
		fformat[length - 1] = '\0';

		// get the rest of the arguments
		va_start(args, format);

		// use vfprintf() to 
		vfprintf(logfile, fformat, args); 
		// forces the logmessage to be written into the file right now
		fflush(logfile);

		va_end(args);

		// free the allocated memory for the format string
		free(fformat);
	} 
	else 
	{
		// close the logfile
		fclose(logfile);
	}
}

while(1)
{

	scanf("%s %d",mystr,&val);
	//fgets(mystr,strlen(mystr),stdin);

	//read(STDIN_FILENO,mystr,sizeof(mystr));
	if(strcmp(mystr,"quit") == 0)
	{
		bacnet0_log("%s\n",mystr); 
		exit(EXIT_SUCCESS);

	}
	//fgets(mystr,sizeof(mystr),stdin);
	//read(STDIN_FILENO,mystr,sizeof(mystr));

	//		printf("%s %d",mystr,val+1);
	bacnet0_log("%s\n",mystr); 

	memset(mystr,0,sizeof(mystr));


}

if(!(format == NULL && logfile == NULL)) {
	// open the logfile if not already opened
	if(logfile == NULL) {
		logfile = fopen(LOG_FILE, "w");
		// if that doesn't work exit with an error message
		if(logfile == NULL) {
			fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
			exit(EXIT_FAILURE);
		}
	}

	// if NULL is given as format, close the opened file
	if(format != NULL) {
		// increase length by 2 (for \n\0
		length = strlen(format) + 2;
		// allocate memory
		fformat = malloc(sizeof(char) * length);
		// copy the format over
		strncpy(fformat, format, length - 2);
		// append \n\0
		//fformat[length - 2] = '\n';
		fformat[length - 2] = '\0';
		fformat[length - 1] = '\0';

		// get the rest of the arguments
		va_start(args, format);

		// use vfprintf() to 
		vfprintf(logfile, fformat, args); 
		// forces the logmessage to be written into the file right now
		fflush(logfile);

		va_end(args);

		// free the allocated memory for the format string
		free(fformat);
	} 
	else 
	{
		// close the logfile
		fclose(logfile);
	}
}

int fd_flags;

fcntl(0,F_SETOWN,getpid());
fd_flags = fcntl(0,F_GETFL);

fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

static char input[1];

kbcbuf.aio_fildes = 0;
kbcbuf.aio_buf = input;
kbcbuf.aio_nbytes = 1;
kbcbuf.aio_offset = 0;


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
kbcbuf.aio_sigevent.sigev_signo = SIGIO;

fgets(cmd_str,128,stdin);
printf("cmd_str is %s\n",cmd_str);

if(strcmp(cmd_str,"quit\n") == 0)
{

	exit(EXIT_SUCCESS);
}

if(strcmp(cmd_str,"whois\n") ==0)
{
	make_internet_address("192.168.0.255",PORT,&cliaddr);
	if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	{
		perror("udp  send failed\n");
		exit(EXIT_FAILURE);		

	}



}


memset(cmd_str,0,sizeof(cmd_str));

int c;
char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

if(aio_error(&kbcbuf) != 0)
{
	perror("reading failed");
}
else
{
	if(aio_return(&kbcbuf) == 1)
	{
		c=*cp;


		if(c == 'q')
		{
			printf("that is it\n");
			exit(EXIT_SUCCESS);

		}

	}

	aio_read(&kbcbuf);

}

struct hostent *hp;

bzero((void*)addrp,sizeof(struct sockaddr_in));


hp = gethostbyname(hostname);

if(hp == NULL)
	return -1;

bcopy((void*)hp->h_addr,(void*)&addrp->sin_addr,hp->h_length);
addrp->sin_port = htons(port);
addrp->sin_family= AF_INET;

return 0;

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{ 
	perror("socket creation failed"); 
	exit(EXIT_FAILURE); 
} 


int optval =1;
setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST|SO_REUSEADDR,&optval,sizeof(int));

struct timeval timeout;
timeout.tv_sec = 6;
timeout.tv_usec = 0;
setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 
// Filling server information 
servaddr.sin_family    = AF_INET; // IPv4 
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 
//servaddr.sin_port = PORT; 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 ) 
{ 
	perror("bind failed"); 
	exit(EXIT_FAILURE); 
} 

int len, n; 
len = sizeof(cliaddr);  //len is value/resuslt 

memset(buffer,0,sizeof(buffer));

}

printf("argc is %d\n",argc);
	if(strcmp(argv[1],"whois") == 0)
	{

		make_internet_address("192.168.0.255",PORT,&cliaddr);
		if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
		{
			perror("udp send failed\n");
		}
	}


}

int fpid;
fpid = fork();
if(fpid == -1)
{
	perror("fork failed\n");
	exit(EXIT_FAILURE);
}
else if(fpid == 0)
{

	//execl("./myudp-tx",0);
	execl("./myudp-tx","myudp-tx",(char*)0);
}


int pfd[2] = {0};

if(pipe(pfd) == -1)
{
	perror("pipe failed\n");
}


fpid = fork();
if(fpid == -1)
{
	perror("fork failed\n");
	exit(EXIT_FAILURE);
}
else if(fpid == 0)
{

	if(dup2(pfd[0],STDIN_FILENO) != STDIN_FILENO)
	{
		perror("dup2 stdin failed\n");
	}

	close(pfd[1]);

	

	//execl("./myudp-tx",0);
	execl("./myudp-dat-processing","myudp-dat-processing",(char*)0);
}

if(dup2(pfd[1],STDOUT_FILENO) != STDOUT_FILENO)
{
	perror("dup2 stdout failed\n");
}

close(pfd[0]);



while(1)
{
	//pause();

	//buffer[n] = '\0'; 
	//	printf("Client : %s\n", buffer); 
	//printf("buffer is %s\n",buffer);

	if(buffer[12]== 0xc4 && buffer[13] == 0x02)
	{

		//	printf("I am %d\n",1009);
		//printf("I am %d\n",(uint32_t)(buffer[14]<<16|buffer[15]<<8|buffer[16]));
	//	printf("%s %d\n","hello",23);
		//printf("%s\r\n","hello");
		//write(pfd[1],ts,strlen(ts));

	}

	//if(buffer[5] == 0x20)
	if(strcmp(buffer,"whois\n") == 0)
	{

		//printf("I am: %d\n",1009);
		//printf("%s %d\n","world",88);
		//puts("world");
		write(pfd[1],ts,strlen(ts));
	}

	//if(sendto(sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	//if(sendto(sockfd,brp_im,sizeof(brp_im),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)

	}

	char *ts="hello";
	if(strcmp(buffer,"hello UDP\n") == 0)
	{
		//printf("good-bye\n");
		printf("%s %d\n","hellox",12);
		//puts("quit");
		//write(pfd[1],ts,strlen(ts));

	}



	char *qt="quit";
	if(strcmp(buffer,"tx-quit\n") == 0)
	{
		//printf("good-bye\n");
		printf("%s %d\n","quit",12);
		//puts("quit");
		//write(pfd[1],qt,strlen(qt));
		close(pfd[1]);
		exit(EXIT_SUCCESS);		

	}



	memset(buffer,0,sizeof(buffer));
	//	sleep(1);
}

if(!(format == NULL && logfile == NULL)) {
	// open the logfile if not already opened
	if(logfile == NULL) {
		logfile = fopen(LOG_FILE, "w");
		// if that doesn't work exit with an error message
		if(logfile == NULL) {
			fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
			exit(EXIT_FAILURE);
		}
	}

	// if NULL is given as format, close the opened file
	if(format != NULL) {
		// increase length by 2 (for \n\0
		length = strlen(format) + 2;
		// allocate memory
		fformat = malloc(sizeof(char) * length);
		// copy the format over
		strncpy(fformat, format, length - 2);
		// append \n\0
		//fformat[length - 2] = '\n';
		fformat[length - 2] = '\0';
		fformat[length - 1] = '\0';

		// get the rest of the arguments
		va_start(args, format);

		// use vfprintf() to 
		vfprintf(logfile, fformat, args); 
		// forces the logmessage to be written into the file right now
		fflush(logfile);

		va_end(args);

		// free the allocated memory for the format string
		free(fformat);
	} 
	else 
	{
		// close the logfile
		fclose(logfile);
	}
}

int fd_flags;

fcntl(0,F_SETOWN,getpid());
fd_flags = fcntl(0,F_GETFL);

fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

static char input[1];

kbcbuf.aio_fildes = 0;
kbcbuf.aio_buf = input;
kbcbuf.aio_nbytes = 1;
kbcbuf.aio_offset = 0;


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
kbcbuf.aio_sigevent.sigev_signo = SIGIO;

fgets(cmd_str,128,stdin);
printf("cmd_str is %s\n",cmd_str);

if(strcmp(cmd_str,"quit\n") == 0)
{

	exit(EXIT_SUCCESS);
}

if(strcmp(cmd_str,"whois\n") ==0)
{
	make_internet_address("192.168.0.255",PORT,&cliaddr);
	if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	{
		perror("udp  send failed\n");
		exit(EXIT_FAILURE);		

	}



}


memset(cmd_str,0,sizeof(cmd_str));

int c;
char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

if(aio_error(&kbcbuf) != 0)
{
	perror("reading failed");
}
else
{
	if(aio_return(&kbcbuf) == 1)
	{
		c=*cp;


		if(c == 'q')
		{
			printf("that is it\n");
			exit(EXIT_SUCCESS);

		}

	}

	aio_read(&kbcbuf);

}

struct hostent *hp;

bzero((void*)addrp,sizeof(struct sockaddr_in));


hp = gethostbyname(hostname);

if(hp == NULL)
	return -1;

bcopy((void*)hp->h_addr,(void*)&addrp->sin_addr,hp->h_length);
addrp->sin_port = htons(port);
addrp->sin_family= AF_INET;

return 0;

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{ 
	perror("socket creation failed"); 
	exit(EXIT_FAILURE); 
} 


int optval =1;
setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST|SO_REUSEADDR,&optval,sizeof(int));

struct timeval timeout;
timeout.tv_sec = 6;
timeout.tv_usec = 0;
setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 
// Filling server information 
servaddr.sin_family    = AF_INET; // IPv4 
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 
//servaddr.sin_port = PORT; 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 ) 
{ 
	perror("bind failed"); 
	exit(EXIT_FAILURE); 
} 

int len, n; 
len = sizeof(cliaddr);  //len is value/resuslt 

memset(buffer,0,sizeof(buffer));

}

printf("argc is %d\n",argc);
	if(strcmp(argv[1],"whois") == 0)
	{

		make_internet_address("192.168.0.255",PORT,&cliaddr);
		if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
		{
			perror("udp send failed\n");
		}
	}


}

int fpid;
fpid = fork();
if(fpid == -1)
{
	perror("fork failed\n");
	exit(EXIT_FAILURE);
}
else if(fpid == 0)
{

	//execl("./myudp-tx",0);
	execl("./myudp-tx","myudp-tx",(char*)0);
}


int pfd[2] = {0};

if(pipe(pfd) == -1)
{
	perror("pipe failed\n");
}


fpid = fork();
if(fpid == -1)
{
	perror("fork failed\n");
	exit(EXIT_FAILURE);
}
else if(fpid == 0)
{

	if(dup2(pfd[0],STDIN_FILENO) != STDIN_FILENO)
	{
		perror("dup2 stdin failed\n");
	}

	close(pfd[1]);

	

	//execl("./myudp-tx",0);
	execl("./myudp-dat-processing","myudp-dat-processing",(char*)0);
}

if(dup2(pfd[1],STDOUT_FILENO) != STDOUT_FILENO)
{
	perror("dup2 stdout failed\n");
}

close(pfd[0]);



while(1)
{
	//pause();

	//buffer[n] = '\0'; 
	//	printf("Client : %s\n", buffer); 
	//printf("buffer is %s\n",buffer);

	if(buffer[12]== 0xc4 && buffer[13] == 0x02)
	{

		//	printf("I am %d\n",1009);
		//printf("I am %d\n",(uint32_t)(buffer[14]<<16|buffer[15]<<8|buffer[16]));
	//	printf("%s %d\n","hello",23);
		//printf("%s\r\n","hello");
		//write(pfd[1],ts,strlen(ts));

	}

	//if(buffer[5] == 0x20)
	if(strcmp(buffer,"whois\n") == 0)
	{

		//printf("I am: %d\n",1009);
		//printf("%s %d\n","world",88);
		//puts("world");
		write(pfd[1],ts,strlen(ts));
	}

	//if(sendto(sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	//if(sendto(sockfd,brp_im,sizeof(brp_im),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)

	}

	char *ts="hello";
	if(strcmp(buffer,"hello UDP\n") == 0)
	{
		//printf("good-bye\n");
		printf("%s %d\n","hellox",12);
		//puts("quit");
		//write(pfd[1],ts,strlen(ts));

	}



	char *qt="quit";
	if(strcmp(buffer,"tx-quit\n") == 0)
	{
		//printf("good-bye\n");
		printf("%s %d\n","quit",12);
		//puts("quit");
		//write(pfd[1],qt,strlen(qt));
		close(pfd[1]);
		exit(EXIT_SUCCESS);		

	}



	memset(buffer,0,sizeof(buffer));
	//	sleep(1);
}

if(!(format == NULL && logfile == NULL)) {
	// open the logfile if not already opened
	if(logfile == NULL) {
		logfile = fopen(LOG_FILE, "w");
		// if that doesn't work exit with an error message
		if(logfile == NULL) {
			fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
			exit(EXIT_FAILURE);
		}
	}

	// if NULL is given as format, close the opened file
	if(format != NULL) {
		// increase length by 2 (for \n\0
		length = strlen(format) + 2;
		// allocate memory
		fformat = malloc(sizeof(char) * length);
		// copy the format over
		strncpy(fformat, format, length - 2);
		// append \n\0
		//fformat[length - 2] = '\n';
		fformat[length - 2] = '\0';
		fformat[length - 1] = '\0';

		// get the rest of the arguments
		va_start(args, format);

		// use vfprintf() to 
		vfprintf(logfile, fformat, args); 
		// forces the logmessage to be written into the file right now
		fflush(logfile);

		va_end(args);

		// free the allocated memory for the format string
		free(fformat);
	} 
	else 
	{
		// close the logfile
		fclose(logfile);
	}
}

int fd_flags;

fcntl(0,F_SETOWN,getpid());
fd_flags = fcntl(0,F_GETFL);

fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

static char input[1];

kbcbuf.aio_fildes = 0;
kbcbuf.aio_buf = input;
kbcbuf.aio_nbytes = 1;
kbcbuf.aio_offset = 0;


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
kbcbuf.aio_sigevent.sigev_signo = SIGIO;

fgets(cmd_str,128,stdin);
printf("cmd_str is %s\n",cmd_str);

if(strcmp(cmd_str,"quit\n") == 0)
{

	exit(EXIT_SUCCESS);
}

if(strcmp(cmd_str,"whois\n") ==0)
{
	make_internet_address("192.168.0.255",PORT,&cliaddr);
	if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	{
		perror("udp  send failed\n");
		exit(EXIT_FAILURE);		

	}



}


memset(cmd_str,0,sizeof(cmd_str));

int c;
char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

if(aio_error(&kbcbuf) != 0)
{
	perror("reading failed");
}
else
{
	if(aio_return(&kbcbuf) == 1)
	{
		c=*cp;


		if(c == 'q')
		{
			printf("that is it\n");
			exit(EXIT_SUCCESS);

		}

	}

	aio_read(&kbcbuf);

}

struct hostent *hp;

bzero((void*)addrp,sizeof(struct sockaddr_in));


hp = gethostbyname(hostname);

if(hp == NULL)
	return -1;

bcopy((void*)hp->h_addr,(void*)&addrp->sin_addr,hp->h_length);
addrp->sin_port = htons(port);
addrp->sin_family= AF_INET;

return 0;

//gethostname(hname,sizeof(hname));
//hent = gethostbyname(hname);

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{ 
	perror("socket creation failed"); 
	exit(EXIT_FAILURE); 
} 


int optval =1;
setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST|SO_REUSEADDR,&optval,sizeof(int));

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 
// Filling server information 
servaddr.sin_family    = AF_INET; // IPv4 
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 
//servaddr.sin_port = PORT; 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr,  
			sizeof(servaddr)) < 0 ) 
{ 
	perror("bind failed"); 
	exit(EXIT_FAILURE); 
} 

int len, n; 
len = sizeof(cliaddr);  //len is value/resuslt 

memset(buffer,0,sizeof(buffer));

}

printf("argc is %d\n",argc);
	if(strcmp(argv[1],"whois") == 0)
	{

		make_internet_address("192.168.0.255",PORT,&cliaddr);
		if(sendto(sockfd,bqr_whois,sizeof(bqr_whois),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
		{
			perror("udp send failed\n");
		}
	}


}

int ifd=0;


if(pipe(fds) == -1)
{
	perror("create pipe failed\n");
	exit(EXIT_SUCCESS);
}



//ifd = dup(fds[1]);
close(0);
ifd = dup(fds[0]);
close(fds[0]);

if(ifd !=0)
{
	perror("dup failed\n");
	exit(EXIT_SUCCESS);
}

int ffd;
ffd = open("./ufifo",O_RDONLY);


if(ffd == -1)
{
	perror("open fifo failed\n");
	exit(EXIT_FAILURE);
}



while(1)
{
	//pause();

	//buffer[n] = '\0'; 
	//	printf("Client : %s\n", buffer); 
	//

	if(fp ==NULL)
	{
		perror("fdopen failed\n");
		exit(EXIT_SUCCESS);
	}

	read(ffd,buffer,sizeof(buffer));

//	fgets(buffer,sizeof(buffer),stdin);
	//read(ifd,buffer,sizeof(buffer));
	//fgets(buffer,sizeof(buffer),fp);

	//if(sendto(sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	//if(sendto(sockfd,brp_im,sizeof(brp_im),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)
	if(strcmp(buffer,"whois\n") == 0)
	{
		printf("got whois\n");
		//make_internet_address("192.168.43.255",PORT,&cliaddr);
		//make_internet_address("10.78.146.1",PORT,&cliaddr);
		//make_internet_address("192.168.0.104",PORT,&cliaddr);
		make_internet_address("192.168.0.255",PORT,&cliaddr);
		//make_internet_address("127.0.0.1",PORT,&cliaddr);

		char* test_udp_str = "hello UDP\n";
		uint32_t stn=0;
		if((stn = sendto(sockfd,test_udp_str,strlen(test_udp_str),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr))) == -1)
		{
			perror("udp send failed\n");
			exit(EXIT_FAILURE);		
		}

		printf("udp send ok: %d\n",stn);



	}

	if(strcmp(buffer,"quit\n") == 0)
	{


		char *qt = "tx-quit\n";
		if(sendto(sockfd,qt,strlen(qt),0,(struct sockaddr*)&cliaddr,sizeof(cliaddr)) == -1)


		{
			perror("udp send failed\n");
			exit(EXIT_FAILURE);		
		}

		printf("udp send ok\n");


		printf("good-bye\n");
		exit(EXIT_SUCCESS);		

	}



	memset(buffer,0,sizeof(buffer));
	//	sleep(1);
}

/* Block SIGALRM in this thread */
sigemptyset (&(info->alarm_sig));
sigaddset (&(info->alarm_sig), SIGALRM);
pthread_sigmask (SIG_BLOCK, &(info->alarm_sig), NULL);

/* Set the timer to go off after the first period and then
   repetitively */

value.it_value.tv_sec = 1;
value.it_value.tv_usec = 0;
value.it_interval.tv_sec = 1;
value.it_interval.tv_usec = 0;



ret = setitimer (ITIMER_REAL, &value, NULL);
if (ret != 0)
	perror ("Failed to set timer");
return ret;

/* Wait for the next SIGALRM */
sigwait (&(info->alarm_sig), &sig);

make_periodic (10000, &info);
while (1)
{
	/* Do useful work */
	printf("hello world!\n");
	wait_period (&info);
}

fd_set fds;
struct timeval tv={5,0};
int retval;


int scnt=0;

int nread,i;
int tnread;
int nwrite=0;
int cnt=0;
int s=0;
int tlen=0;

char wbuff[64] = "Hello\n";
uint8_t recbuf[BLEN]={0};
uint8_t *precbuf=recbuf;
int cnt_rec=0;
int c;

char rbuff[BLEN] = {0};

if(fd == -1)
{	
	perror("can not open serial port failed\n");
	exit(EXIT_FAILURE);
}

printf("fd is %d\n",fd);

//tcflush(fd,TCIFLUSH);
tcflush(fd,TCIOFLUSH);

cnt_rec=0;

char cmd[128] = "dht11";

//tlen = write(fd,cmd,6);

memset(recbuf,0,sizeof(recbuf));
tlen = write(fd,cmd,5);
while(1)
{

	FD_ZERO(&fds);
	FD_SET(fd,&fds);
	
	tv.tv_sec =5;
	tv.tv_usec = 500000;
	//sleep(1);

//	tlen = write(fd,cmd,5);
	retval = select(fd+1,&fds,NULL,NULL,&tv);
	//retval = select(fd+1,&fds,NULL,NULL,NULL);

	if(retval == -1)
	{
		printf("error:select\n");
		close(fd);
		exit(EXIT_FAILURE);

	}
	else if(retval)
	{
		if(FD_ISSET(fd,&fds))
		{
		//	memset(recbuf,0,sizeof(recbuf));
			tlen =read(fd,precbuf,BLEN);	
		//	printf("m is %s\n",precbuf);
		//	printf("mlen is %d\n",tlen);
			precbuf +=tlen;
			//tlen =read(fd,recbuf,8);	

			//	tlen = write(fd,cmd,6);
			
		}
	}

		precbuf = recbuf;
		printf("message is %s\n",precbuf);

		printf("send cmd %d\n",scnt++);
		//printf("tlen is %d\n",tlen);

		//exit(EXIT_FAILURE);
	}

}

	nwrite= write(fd,recbuf,nread);
	printf("nwrite is %d\n",nwrite);

	tnread=0;
	while(tnread != nwrite)
	{

		printf("---tnread is %d---\n",tnread);

		nread = read(fd,rbuff,BLEN);
		tnread +=nread;
		printf("---nread is %d---\n",nread);
		write(wfd,rbuff,nread);
	}


}

close(wfd);
close(rfd);
close(fd);

if($2*2==($4+$2))
{
	print "====="
		print "data is " $2 " " $4
		print "dat is " $2*2 
		print NR
}

int nread,i;
int tnread;
int nwrite=0;
int cnt=0;
int s=0;

char wbuff[64] = "Hello\n";
char recbuf[1024]={0};
int cnt_rec=0;
int c;

char rbuff[BLEN] = {0};

wfd = open("acom.log",O_WRONLY);
rfd = open(argv[1],O_RDONLY);

if(fd == -1)
{	
	perror("can not open serial port failed\n");
	exit(EXIT_FAILURE);
}

printf("fd is %d\n",fd);

cnt_rec=0;

while((nread =read(rfd,recbuf,BLEN)) > 0)	
{

	nwrite= write(fd,recbuf,nread);
	printf("nwrite is %d\n",nwrite);

	tnread=0;
	while(tnread != nwrite)
	{

		printf("---tnread is %d---\n",tnread);

		nread = read(fd,rbuff,BLEN);
		tnread +=nread;
		printf("---nread is %d---\n",nread);
		write(wfd,rbuff,nread);
	}


}

close(wfd);
close(rfd);
close(fd);
printf("done\n");
return 0;

// if NULL is given as format, close the opened file
if(format != NULL) {
  // increase length by 2 (for \n\0
  length = strlen(format) + 2;
  // allocate memory
  fformat = malloc(sizeof(char) * length);
  // copy the format over
  strncpy(fformat, format, length - 2);
  // append \n\0
  fformat[length - 2] = '\n';
  fformat[length - 1] = '\0';

  // get the rest of the arguments
  va_start(args, format);

  // use vfprintf() to 
  vfprintf(logfile, fformat, args); 
  // forces the logmessage to be written into the file right now
  fflush(logfile);
 
  va_end(args);

  // free the allocated memory for the format string
  free(fformat);
} 
else 
{
  // close the logfile
  fclose(logfile);
}

// select the first menu entry if enter is pressed
if(ch == '\n') ch = '1';
// a number pressed?
if(ch >= '0' && ch <= '9') {
  number = ch - '0';
  // prevent from handling numbers which are > than the number of menu entries
  if(ch - '0' <= lines) {
    // get out of the loop
    break;
  }
}

int fd_flags;

fcntl(0,F_SETOWN,getpid());
fd_flags = fcntl(0,F_GETFL);

fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

static char input[1];

kbcbuf.aio_fildes = 0;
kbcbuf.aio_buf = input;
kbcbuf.aio_nbytes = 1;
kbcbuf.aio_offset = 0;


kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
kbcbuf.aio_sigevent.sigev_signo = SIGIO;

n_sec = n_msecs/1000;
n_usec = (n_msecs%1000)*1000L;

new_timeset.it_interval.tv_sec = n_sec;
new_timeset.it_interval.tv_usec = n_usec;

new_timeset.it_value.tv_sec = n_sec;
new_timeset.it_value.tv_usec = n_usec;

return setitimer(ITIMER_REAL,&new_timeset,NULL);

switch(dir)
{
	case DIR_UP:
		cx -=1;
		break;

	case DIR_DOWN:

		cx +=1;
		break;

	case DIR_LEFT:

		cy -=1;
		break;

	case DIR_RIGHT:

		cy +=1;
		break;
}

move(11,10);	
printw("body_len is  %d",body_len);

	body[j].posx = body[j-1].posx;
	body[j].posy = body[j-1].posy;

}

body[j].posx =cx;
body[j].posy =cy;

for(j=0;j<body_len;j++)
{
	move(body[j].posx,body[j].posy); 
	if(j ==0)
	{
		addch(HEAD);
	}
	else
	{

		addch(BODY);
	}

}


move(body[body_len].posx,body[body_len].posy);
addch(BLANK);

char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

if(aio_error(&kbcbuf) != 0)
{
	perror("reading failed");
}
else
{
	if(aio_return(&kbcbuf) == 1)
	{
		c=*cp;
		onkey = c;
		move(15,15);
		addch(c);
		refresh();

		if(c == 'x')
		{
			switch(dir)
			{
				case DIR_UP:
					body[body_len].posx = body[body_len -1].posx+1; 
					body[body_len].posy = body[body_len -1].posy;
					body_len++;

					break;

				case DIR_DOWN:

					body[body_len].posx = body[body_len -1].posx-1; 
					body[body_len].posy = body[body_len -1].posy;
					body_len++;


					break;

				case DIR_LEFT:

					body[body_len].posx = body[body_len -1].posx; 
					body[body_len].posy = body[body_len -1].posy+1;
					body_len++;


					break;

				case DIR_RIGHT:

					body[body_len].posx = body[body_len -1].posx; 
					body[body_len].posy = body[body_len -1].posy-1;
					body_len++;

					break;

			}


			int m;

			for(m=0;m<body_len;m++)
			{
				move(body[m].posx,body[m].posy); 
				if(m ==0)
				{
					addch(HEAD);
				}
				else
				{

					addch(BODY);
				}

			}

			refresh();

		}

		if(c == 'q')
		{
			endwin();	
			printf("that is it\n");
			exit(EXIT_SUCCESS);

		}

	}

	aio_read(&kbcbuf);

}

initscr();
// get more control over the input
cbreak();
// getch() returns ERR if no input is present and doesn't wait
//nodelay(stdscr, TRUE);
// don't echo the inserted keys to the screen
noecho();
// colors!
start_color();
set_colors();
// also grab keys like F1 etc.
keypad(stdscr, TRUE);

gethostname(hname,sizeof(hname));
hent = gethostbyname(hname);

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
{ 
	perror("socket creation failed"); 
	exit(EXIT_FAILURE); 
} 

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 
// Filling server information 
servaddr.sin_family    = AF_INET; // IPv4 
//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 
//servaddr.sin_port = PORT; 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr,  
			sizeof(servaddr)) < 0 ) 
{ 
	perror("bind failed"); 
	exit(EXIT_FAILURE); 
} 

int len, n; 
len = sizeof(cliaddr);  //len is value/resuslt 

WINDOW *xw;
	void on_input(int);
signal(SIGIO,on_input);
//enable_kbd_signals();

setup_aio_buffer();
aio_read(&kbcbuf);


set_ticker(200);

signal(SIGALRM,on_timer);
init_curses();
curs_set(0);



int ti,tj;

body[1].posx=30;
body[1].posy=29;

for(ti=0;ti<body_len;ti++)
{

	body[ti].posx=30;
	body[ti].posy=30-ti;

	move(body[ti].posx,body[ti].posy);

	if(ti == 0)
	{
		addch(HEAD);
	}
	else
	{

		addch(BODY);
	}

}
refresh();


cx = body[0].posx;
cy = body[0].posy;

while(1)
{

	switch(onkey)
	{

		case 'w':
			dir = DIR_UP;

			break;

		case 's':

			dir = DIR_DOWN;
			break;

		case 'a':

			dir = DIR_LEFT;
			break;

		case 'd':

			dir = DIR_RIGHT;
			break;

	}

	buffer[n] = '\0'; 
	//printf("Client : %s\n", buffer); 
	move(25,25);
	printw("Client : %s\n", buffer); 
	refresh();

//	sleep(4);
end_curses();

		printf("read com\r\n");
		nread = read(fd,rbuf,sizeof(rbuf)-2);
	//	printf("nread is %d\r\n",nread);
		printf("rbuf is %s\r\n",rbuf);
		memset(rbuf,sizeof(rbuf),0);

		if(nread)
		{
			tnread += nread;
			nread =0;

		//	printf("tnread is %d\r\n",tnread);
		}
		flag=0;

	}
}

int cnt=0;
wbuf[0] = 'h';
wbuf[1] = 'e';
wbuf[2] = 'l';
wbuf[3] = 'l';
wbuf[4] = 'o';
wbuf[5] = '\r';
wbuf[6] = '\n';
wbuf[7] = '\0';
while(1)
{

	printf("write com\r\n");
	nwrite= write(fd,wbuf,strlen(wbuf));
	//printf("nwrite is %d\r\n",nwrite);
	memset(wbuf,sizeof(wbuf),0);
	flag =1;
	sleep(6);
	cnt++;
	if(cnt > 3)
	{
		//cnt=0;
		//fsync(fd);
		sleep(6);
		break;
	}
}

fd = open("/dev/ttyS7",O_RDWR);



if(fd == -1)
{	
	perror("can not open serial port failed\n");
	exit(EXIT_FAILURE);
}

printf("fd is %d\n",fd);


pthread_t  thread1,thread2;
int iret1,iret2;

iret1 = pthread_create(&thread1,NULL,read_com,NULL);	
iret2 = pthread_create(&thread2,NULL,write_com,NULL);	


pthread_join(thread1,NULL);
pthread_join(thread1,NULL);


printf("thread 1 returns %d\n",iret1);
printf("thread 2 returns %d\n",iret2);

close(fd);
printf("done\n");
return 0;

if( FindAttribute(elem, "blockType") )
    blockType = getBlockType(FindAttribute(elem, "blockType")->Value());
if( FindAttribute(elem, "blockSize") )
    blockSize = hex2int(FindAttribute(elem, "blockSize")->Value(), 8);

switch( blockType )
{
case OTA:
    binfile.addChild(img->OTApackage);
    break;
case FCT:
    binfile.addChild(img->FCTpackage);
    break;
default:
    break;
}

if( blockSize > gsize() )
    reserved.set(blockSize - gsize());

if( FindAttribute(elem, "blockType") )
    blockType = getBlockType(FindAttribute(elem, "blockType")->Value());
if( FindAttribute(elem, "blockSize") )
    blockSize = hex2int(FindAttribute(elem, "blockSize")->Value(), 8);

switch( blockType )
{
case OTA:
    img->OTApackage = new package(nullptr, fp);
    binfile.addChild(img->OTApackage);
    break;
case FCT:
    img->FCTpackage = new fctpack(elem, fp);
    binfile.addChild(img->FCTpackage);
    break;
default:
    break;
}

if( blockSize > gsize() )
    reserved.set(blockSize - gsize(), fp);

if(str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
    str += 2;

for(int i = 0; i < digit; ++i)
{
    c = *str;
    if(c >= '0' && c <= '9')
        c = c - '0';
    else if(c >= 'a' && c <= 'f')
        c = c - 'a' + 10;
    else if(c >= 'A' && c <= 'F')
        c = c - 'A' + 10;
    else
        break;
    res <<= 4;
    res |= c;
    ++str;
}

return res;

for(int i = 0; i < digit; ++i)
{
    n = 0;

    while( (c = *str) && c >= '0' && c <= '9' )
    {
        c = c - '0';
        ++str;
        n = n * 10 + c;
    }

    c = *str;
    res |= n << (i * 8);
    if( c != '.' )
        break;
    ++str;
}

return res;

Element* res;

if( strcmp(elem->Value(), name) == 0 )
    return elem;

if( elem->FirstChildElement() != nullptr )
{
    elem = elem->FirstChildElement();
    while( elem )
    {
        res = findElement(elem, name);
        if( res )
            return res;
        elem = elem->NextSiblingElement();
    }
}

return nullptr;

cout << "Signing... ";

const char* signingTool = "\\RawKeySigner.exe";
const char* option1 = " -in ";
const char* option2 = " -env ";
const char* option3 = " -cert ";
const char* option4 = " -worker ";
const char* option5 = " -out ";
const char* signatureFile = "temp.sig ";

remove(signatureFile);

char command[256] = {0};

strcat(command, signToolPath);
strcat(command, signingTool);
if( access(command, F_OK) != 0 )
{
    cout << "Signing tool not found. " << endl;
    return false;
}
strcat(command, option1);
strcat(command, file);
strcat(command, option2);
if( SignEnv == nullptr )
{
    cout << "Missing sign environment. " << endl;
    return false;
}
strcat(command, SignEnv);
strcat(command, option3);
if( fixtureName == nullptr )
{
    cout << "Missing fixture name. " << endl;
    return false;
}
strcat(command, fixtureName);
strcat(command, option4);
if( workerName == nullptr )
{
    cout << "Missing worker name. " << endl;
    return false;
}
strcat(command, workerName);
strcat(command, option5);
strcat(command, signatureFile);

char strbuf[256];
FILE* pPipe;
if( ( pPipe = _popen(command, "r") ) == nullptr )
	perror("Fail to open a pipe. ");

char* str;
char* pos;
while( (str = fgets( strbuf, 256, pPipe )) )
{

		for(int i = 0; i < 32; ++i)
			buf[i] = hex2int(pos + i * 3, 2);

		fgets( strbuf, 256, pPipe );
		pos = strstr(str, "pS: ");
		if(pos == nullptr)
			break;
		pos += strlen("pS: ");

		for(int i = 0; i < 32; ++i)
			buf[i+32] = hex2int(pos + i * 3, 2);

		FILE* fp = fopen(signatureFile, "rb");
		fclose(fp);
		remove(signatureFile);
		cout << "done. " << endl;
		return true;
	}
}

FILE* fp = fopen(signatureFile, "rb");
fclose(fp);
remove(signatureFile);
cout << "fail. " << endl;
return false;

cout << "Verify... ";

const char* verifyTool = "\\VerifySignature -in ";
const char* option1 = " -sig ";
const char* option2 = " -cert ";

uint8_t sigP[SigLen];
uint8_t sigO[SigLen];
FILE* fp = fopen(sig, "rb+");
fread(sigP, SigLen, 1, fp);
for(uint8_t i = 0; i < SigLen / 2; ++i)
    sigO[i] = sigP[SigLen/2-i-1];
for(uint8_t i = SigLen / 2; i < SigLen; ++i)
    sigO[i] = sigP[SigLen-i-1+SigLen/2];
fseek(fp, 0, SEEK_SET);
fwrite(sigO, SigLen, 1, fp);
fclose(fp);

char command[256] = {0};

strcat(command, verifyToolPath);
strcat(command, verifyTool);
strcat(command, file);
strcat(command, option1);
strcat(command, sig);
strcat(command, option2);
strcat(command, verifyToolPath);
strcat(command, "\\");
strcat(command, cert);

char strbuf[256];
FILE* pPipe;
if( ( pPipe = _popen(command, "r") ) == nullptr )
	perror("Fail to open a pipe. ");

char* str;
char* pos;
while( (str = fgets( strbuf, 256, pPipe )) )
{
    pos = strstr(str, "Verifying signature... ");
    if( pos == nullptr )
        continue;
    pos += strlen("Verifying signature... ");
    pos = strstr(pos, "OK");
    if( pos == nullptr )
        break;
    cout << "done. " << endl;
    return true;
}
cout << "fail. " << endl;
return false;

RandomArray(seed, seedLen, value, len);
delete[] seed;

findelem = element->FirstChildElement();
while( findelem )
{
    ++mcuNumber;
    findelem = findelem->NextSiblingElement();
}

vector4d* destAddrTable = new vector4d[mcuNumber];
findelem = element->FirstChildElement();

for(int i = 0; i < mcuNumber; ++i )
{
	attribute = FindAttribute(findelem, "Firmware");
	destAddrTable[i][0] = hex2int(attribute->Value(), 8);
	attribute = FindAttribute(findelem, "Bootloader");
	destAddrTable[i][1] = hex2int(attribute->Value(), 8);
	attribute = FindAttribute(findelem, "Configuration");
	destAddrTable[i][2] = hex2int(attribute->Value(), 8);
	attribute = FindAttribute(findelem, "OTAkey");
	destAddrTable[i][3] = hex2int(attribute->Value(), 8);
	findelem = findelem->NextSiblingElement();
}

return destAddrTable;

static uint32_t offAccum;

Tnode owner      = {(char*)"owner",      1};
Tnode type       = {(char*)"type",       1};
Tnode productID  = {(char*)"productID",  4};
Tnode HWversion  = {(char*)"HWversion",  4};
Tnode version    = {(char*)"version",    4};
Tnode offset     = {(char*)"offset",     4};
Tnode moduleSize = {(char*)"moduleSize", 4};
Tnode destAddr   = {(char*)"destAddr",   4};
Tnode reserved   = {(char*)"reserved",  22};

moduleinfo();
moduleinfo(Element* elem);
moduleinfo(FILE* fp);

Tnode deriveParam   = {(char*)"deriveParam",  32};
Tnode reserved0     = {(char*)"reserved0",    32};
Tnode headerIV      = {(char*)"headerIV",     16};
Tnode packageSize   = {(char*)"packageSize",   4};
Tnode headerLength  = {(char*)"headerLength",  4};
Tnode version       = {(char*)"version",       4};
Tnode moduleCount   = {(char*)"moduleCount",   4};
Tnode moduleinfos;
Tnode enryptionIV   = {(char*)"enryptionIV",  16};
Tnode reserved      = {(char*)"reserved"};
Tnode signature     = {(char*)"signature",    64};

Tnode signArea;
Tnode encryptArea;

Tnode fixArea;
Tnode plainArea;
Tnode signandfixArea;
Tnode sigandvarArea;
Tnode nosignArea;

header();
void set(void);
void set(Element* elem);
void read(FILE* fp);
void readcipher(FILE* fp);
void random(void);

file();
file(const char* n, uint32_t s = 0);

Tnode files   = {(char*)"files"};
Tnode padding = {(char*)"padding"};

package();
package(Element* elem);
package(Element* elem, FILE* fp);

uint32_t offsetLoc;

fctpack();
fctpack(Element* elem);
fctpack(Element* elem, FILE* fp);
void random();

const char* blockTypeList[4] = {"NONE", "OTA", "FCT", "DATA"};
enum blockType_t
{
    NONE = 0,
    OTA = 1,
    FCT = 2,
    DATA = 3,
};

blockType_t getBlockType(const char* type);

uint32_t blockSize = 0;
blockType_t blockType = NONE;

block();
block(Element* elem, image* img);
block(Element* elem, image* img, FILE* fp);

package* OTApackage;
fctpack* FCTpackage;
file* DATApackage;

uint32_t headerSize;
uint32_t flashSize;

image();
image(Element* elem);
image(Element* elem, FILE* fp);

Tnode provMagic         = {(char*)"provMagic",         4};
Tnode provDataVersion   = {(char*)"provDataVersion",   4};
Tnode eccCapacity       = {(char*)"eccCapacity",       4};
Tnode productType       = {(char*)"productType",       4};
Tnode signPublicKey     = {(char*)"signPublicKey",     64};
Tnode latchKey          = {(char*)"latchKey",          32};
Tnode ioProtectKey      = {(char*)"ioProtectKey",      32};
Tnode encryptedWriteKey = {(char*)"encryptedWriteKey", 32};
Tnode encryptedReadKey  = {(char*)"encryptedReadKey",  32};
Tnode rootKey           = {(char*)"rootKey",           32};
Tnode deviceKey         = {(char*)"deviceKey",         32};
Tnode MAC               = {(char*)"MAC",               8};
Tnode serialNumber      = {(char*)"serialNumber",      32};
Tnode reserved          = {(char*)"reserved",          136};
Tnode hashData          = {(char*)"hashData",          32};
Tnode nonce             = {(char*)"nonce",             32};
Tnode hashArea;
Tnode encryptArea;

provdata();
provdata(Element* elem);
bool provIsEncrypt();

bytes(const char* value, uint32_t len)
{
    length = len;
    byte = new uint8_t[len];
    memcpy(byte, value, len);
}

bytes(const uint8_t* value, uint32_t len)
{
    length = len;
    byte = new uint8_t[len];
    memcpy(byte, value, len);
}

~bytes()
{
    if(byte != nullptr)
        delete[] byte;
    byte = nullptr;
    length = 0;
}

bytes(const bytes& lv)
{
    if(byte != nullptr)
        delete[] byte;
    length = lv.length;
    byte = new uint8_t[length];
    memcpy(byte, lv.byte, length);
}

bytes operator+ (const bytes& lv)
{
    uint8_t sum[length + lv.length];
    memcpy(sum, byte, length);
    memcpy(&sum[length], lv.byte, lv.length);
    return bytes(sum, length + lv.length);
}

bytes& operator= (const bytes& lv)
{
    if(byte != nullptr)
        delete[] byte;
    length = lv.length;
    byte = new uint8_t[length];
    memcpy(byte, lv.byte, length);
    return *this;
}

uint32_t size(void)
{
    return length;
}

uint8_t* value(void)
{
    return byte;
}

if(str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
    str += 2;

for(int i = 0; i < digit; ++i)
{
    c = *str;
    if(c >= '0' && c <= '9')
        c = c - '0';
    else if(c >= 'a' && c <= 'f')
        c = c - 'a' + 10;
    else if(c >= 'A' && c <= 'F')
        c = c - 'A' + 10;
    else
        break;
    res <<= 4;
    res |= c;
    ++str;
}
return res;

assert(length <= (0xFF * DIGEST_LENGTH));

uint8_t blockNum;
blockNum = length / DIGEST_LENGTH;
if(length % DIGEST_LENGTH > 0)
    blockNum += 1;

uint8_t* okm = new uint8_t[blockNum * DIGEST_LENGTH];
memset(okm, 0, blockNum * DIGEST_LENGTH);

bytes seed(seedArray, seedLen);
bytes block(seedArray, seedLen);
bytes output_block;

for(int i = 0; i < blockNum; ++i)
{
    block = HmacArray(rtkey, block);
    output_block = HmacArray(rtkey, block + seed);
    memcpy(&okm[i * DIGEST_LENGTH], output_block.value(), DIGEST_LENGTH);
}

for(int i = 0; i < dk_len; ++i)
{
    drvkey[i] = okm[i] ^ okm[i + dk_len];
}

delete[] okm;

const char* n = findElement(elem, "file")->GetText();
FILE* fp = fopen(n, "rb");
if( fp == nullptr )
{
    cout << n << " open error. " << endl;
}
random();
fixArea.read(fp);
part2.set(offset - fixArea.gsize());
part2.read(fp);
if(IsEncrypt)
    encryptArea.encrypt(encKey, encryptIV, IVLen);
fclose(fp);

encryptIV.read(fp);
fixArea.readcipher(fp);
fixArea.decrypt(decKey, encryptIV, IVLen);
part2.set(offset - fixArea.gsize());
part2.readcipher(fp);
encryptArea.decrypt(decKey, encryptIV, IVLen);
if( toolType == EIET && IsEncrypt )
    encryptArea.encrypt(encKey, encryptIV, IVLen);
else if( toolType == EIDT )
    clearcipher();

signandfixArea.addChild(&reserved0);
signandfixArea.addChild(&packageSize);
signandfixArea.addChild(&headerLength);
signandfixArea.addChild(&version);
signandfixArea.addChild(&moduleCount);

sigandvarArea.addChild(&moduleinfos);
sigandvarArea.addChild(&enryptionIV);

nosignArea.addChild(&reserved);
nosignArea.addChild(&signature);

signArea.moveChild(plainArea);
signArea.moveChild(signandfixArea);
signArea.moveChild(sigandvarArea);
encryptArea.moveChild(signandfixArea);
encryptArea.moveChild(sigandvarArea);
encryptArea.moveChild(nosignArea);
fixArea.moveChild(plainArea);
fixArea.moveChild(signandfixArea);

moveChild(plainArea);
moveChild(signandfixArea);
moveChild(sigandvarArea);
moveChild(nosignArea);

FILE* fp;

if( FindAttribute(elem, "headerSize") )
    headerSize = hex2int(FindAttribute(elem, "headerSize")->Value(), 8);
if( FindAttribute(elem, "flashSize") )
    flashSize = hex2int(FindAttribute(elem, "flashSize")->Value(), 8);

if( findElement(elem, "OTA") )
{
    const char* OTApackagePath = findElement(elem, "package")->GetText();
    fp = fopen(OTApackagePath, "rb");
    if( fp == nullptr )
    {
        cout << OTApackagePath << " open error. " << endl;
    }
    OTApackage = new package(elem, fp);
    fclose(fp);
}

if( findElement(elem, "FCT") )
{
    FCTpackage = new fctpack(findElement(elem, "FCT"));
}

elem = findElement(elem, "block");
list<Element*> blockList = makeList(elem, "block");
for(Element* i: blockList)
    blocks.addChild(new block(i, this));

head.set(headerSize);
if( flashSize > gsize() )
    tail.set(flashSize - gsize());

if( FindAttribute(elem, "headerSize") )
    headerSize = hex2int(FindAttribute(elem, "headerSize")->Value(), 8);
if( FindAttribute(elem, "flashSize") )
    flashSize = hex2int(FindAttribute(elem, "flashSize")->Value(), 8);

head.set(headerSize);
head.read(fp);
elem = findElement(elem, "block");
list<Element*> blockList = makeList(elem, "block");
for(Element* i: blockList)
    blocks.addChild(new block(i, this, fp));

if( flashSize > gsize() )
    tail.set(flashSize - gsize());
tail.read(fp);

cout << "OPGT version "
<< ((OPGT_VERSION & 0xFF000000) >> 24 )
<< "."
<< ((OPGT_VERSION & 0x00FF0000) >> 16 )
<< "."
<< ((OPGT_VERSION & 0x0000FF00) >> 8 )
<< "."
<< ((OPGT_VERSION & 0x000000FF) >> 0 )
<< endl;

if(argc <= 1)
{
    cout << "No config file and output file. " << endl;
    return -1;
}

if(argc > 1)
    toolType = getToolType(argv[1]);

if(argc > 2)
    configFile = argv[2];

if(argc > 3)
    outFile = argv[3];

if(argc > 4)
    inFile = argv[4];

if(configFile != nullptr)
{
    if( access(configFile, F_OK) != 0 )
    {
        cout << configFile << " not found. " << endl;
        return -1;
    }
    doc.LoadFile( configFile );
    Element* elem = doc.LastChildElement();
    if(elem == nullptr)
    {
        cout << "Config info not found. " << endl;
        return -1;
    }

    if( inFile != nullptr )
    {
        fp = fopen(inFile, "rb");
        if( toolType == OPDT )
            img = new package(elem, fp);
        else if( toolType == EIET )
            img = new image(elem, fp);
        else if( toolType == EIDT )
            img = new image(elem, fp);
        fclose(fp);
    }
    else
    {
        if( toolType == OPGT )
            img = new package(elem);
        else if( toolType == EIGT )
            img = new image(elem);
        else if( toolType == PDGT )
            img = new provdata(elem);
    }

    if( outFile == nullptr )
        return -1;
    fp = fopen(outFile, "wb");
    img->write(fp);
    fclose(fp);
    cout << "Output done. " << endl;

    beforeExit();
    return 0;
}

return -1;

elem = findElement(elem, "file");
list<Element*> filelist = makeList(elem, "file");
for(Element* i: filelist)
   files.addChild(new file(i->GetText()));

owner     = FindAttribute(elem, "owner")    ->IntValue();
type      = FindAttribute(elem, "type")     ->IntValue();
productID = FindAttribute(elem, "productID")->IntValue();
HWversion = FindAttribute(elem, "HWversion")->IntValue();
version   = version2Int(FindAttribute(elem, "version")->Value(), 4);
destAddr  = destAddrTable[owner-1][type-1];

elem = findElement(elem, "file");
filelist = makeList(elem, "file");
uint32_t fileSize;
for(Element* i: filelist)
{
    fp = fopen(i->GetText(), "rb");
    fileSize = filelength(fileno(fp));
    if( fileSize % 16 > 0 )
        fileSize += 16 - fileSize % 16;
    moduleSize = moduleSize + fileSize;
    fclose(fp);
}

offset = offAccum;
offAccum += moduleSize;

header.set(elem);
moduleinfo::offAccum = 0;
elem = findElement(elem, "module");
list<Element*> modulelist = makeList(elem, "module");
for(Element* i: modulelist)
{
    header.moduleinfos.addChild(new moduleinfo(i));
    modules.addChild(new module(i));
    header.moduleCount = header.moduleCount + 1;
}

header.set();
header.random();
if( rootKey )
    TLS_PRF(rootKey, header.deriveParam.value, SeedLen, EncKeyLen, deriveKey);
header.signArea.sign(header.signature);
signArea.sign(signature);
if(IsEncrypt)
{
    header.encryptArea.encrypt(encKey, header.headerIV, IVLen);
    encryptArea.encrypt(encKey, header.enryptionIV, IVLen);
}

if( rootKey )
    TLS_PRF(rootKey, header.deriveParam.value, SeedLen, EncKeyLen, deriveKey);
header.readcipher(fp);
header.encryptArea.decrypt(decKey, header.headerIV, IVLen);
header.signArea.verify(header.signature);

for(Tnode* i: header.moduleinfos.children)
    modules.addChild(new module((*(moduleinfo*)i), fp));

signature.readcipher(fp);
encryptArea.decrypt(decKey, header.enryptionIV, IVLen);

if( toolType == EIET && IsEncrypt )
{
    header.encryptArea.encrypt(encKey, header.headerIV, IVLen);
    encryptArea.encrypt(encKey, header.enryptionIV, IVLen);
}
else if( toolType == OPDT || toolType == EIDT )
{
    clearcipher();
}

	const char* provKey = "1234567812345678";
	encryptArea.decrypt((uint8_t*)provKey, nonce, IVLen);
}
if( hashArea.verifyDigest(hashData) == false )
{
    cout << "Prov data file verify fail. " << endl;
    throw;
}

Formatting, Artistic Style:
    AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h

Isn't clear why TINYXML2_LIB is needed; but seems to fix #719

    TEXT_ELEMENT		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
    TEXT_ELEMENT_LEAVE_ENTITIES		= NEEDS_NEWLINE_NORMALIZATION,
    ATTRIBUTE_NAME		            = 0,
    ATTRIBUTE_VALUE		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
    ATTRIBUTE_VALUE_LEAVE_ENTITIES  = NEEDS_NEWLINE_NORMALIZATION,
    COMMENT							= NEEDS_NEWLINE_NORMALIZATION
};

StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
~StrPair();

void Set( char* start, char* end, int flags ) {
    TIXMLASSERT( start );
    TIXMLASSERT( end );
    Reset();
    _start  = start;
    _end    = end;
    _flags  = flags | NEEDS_FLUSH;
}

const char* GetStr();

bool Empty() const {
    return _start == _end;
}

void SetInternedStr( const char* str ) {
    Reset();
    _start = const_cast<char*>(str);
}

void SetStr( const char* str, int flags=0 );

char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
char* ParseName( char* in );

void TransferTo( StrPair* other );
void Reset();

enum {
    NEEDS_FLUSH = 0x100,
    NEEDS_DELETE = 0x200
};

int     _flags;
char*   _start;
char*   _end;

StrPair( const StrPair& other );	// not supported
void operator=( const StrPair& other );	// not supported, use TransferTo()

~DynArray() {
    if ( _mem != _pool ) {
        delete [] _mem;
    }
}

void Clear() {
    _size = 0;
}

void Push( T t ) {
    TIXMLASSERT( _size < INT_MAX );
    EnsureCapacity( _size+1 );
    _mem[_size] = t;
    ++_size;
}

T* PushArr( int count ) {
    TIXMLASSERT( count >= 0 );
    TIXMLASSERT( _size <= INT_MAX - count );
    EnsureCapacity( _size+count );
    T* ret = &_mem[_size];
    _size += count;
    return ret;
}

T Pop() {
    TIXMLASSERT( _size > 0 );
    --_size;
    return _mem[_size];
}

void PopArr( int count ) {
    TIXMLASSERT( _size >= count );
    _size -= count;
}

bool Empty() const					{
    return _size == 0;
}

T& operator[](int i)				{
    TIXMLASSERT( i>= 0 && i < _size );
    return _mem[i];
}

const T& operator[](int i) const	{
    TIXMLASSERT( i>= 0 && i < _size );
    return _mem[i];
}

const T& PeekTop() const            {
    TIXMLASSERT( _size > 0 );
    return _mem[ _size - 1];
}

int Size() const					{
    TIXMLASSERT( _size >= 0 );
    return _size;
}

int Capacity() const				{
    TIXMLASSERT( _allocated >= INITIAL_SIZE );
    return _allocated;
}

void SwapRemove(int i) {
	TIXMLASSERT(i >= 0 && i < _size);
	TIXMLASSERT(_size > 0);
	_mem[i] = _mem[_size - 1];
	--_size;
}

const T* Mem() const				{
    TIXMLASSERT( _mem );
    return _mem;
}

T* Mem() {
    TIXMLASSERT( _mem );
    return _mem;
}

void EnsureCapacity( int cap ) {
    TIXMLASSERT( cap > 0 );
    if ( cap > _allocated ) {
        TIXMLASSERT( cap <= INT_MAX / 2 );
        const int newAllocated = cap * 2;
        T* newMem = new T[newAllocated];
        TIXMLASSERT( newAllocated >= _size );
        memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
        if ( _mem != _pool ) {
            delete [] _mem;
        }
        _mem = newMem;
        _allocated = newAllocated;
    }
}

T*  _mem;
T   _pool[INITIAL_SIZE];
int _allocated;		// objects allocated
int _size;			// number objects in use

virtual int ItemSize() const = 0;
virtual void* Alloc() = 0;
virtual void Free( void* ) = 0;
virtual void SetTracked() = 0;

void Clear() {
    // Delete the blocks.
    while( !_blockPtrs.Empty()) {
        Block* lastBlock = _blockPtrs.Pop();
        delete lastBlock;
    }
    _root = 0;
    _currentAllocs = 0;
    _nAllocs = 0;
    _maxAllocs = 0;
    _nUntracked = 0;
}

virtual int ItemSize() const	{
    return ITEM_SIZE;
}
int CurrentAllocs() const		{
    return _currentAllocs;
}

virtual void* Alloc() {
    if ( !_root ) {
        // Need a new block.
        Block* block = new Block();
        _blockPtrs.Push( block );

        Item* blockItems = block->items;
        for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
            blockItems[i].next = &(blockItems[i + 1]);
        }
        blockItems[ITEMS_PER_BLOCK - 1].next = 0;
        _root = blockItems;
    }
    Item* const result = _root;
    TIXMLASSERT( result != 0 );
    _root = _root->next;

    ++_currentAllocs;
    if ( _currentAllocs > _maxAllocs ) {
        _maxAllocs = _currentAllocs;
    }
    ++_nAllocs;
    ++_nUntracked;
    return result;
}

virtual void Free( void* mem ) {
    if ( !mem ) {
        return;
    }
    --_currentAllocs;
    Item* item = static_cast<Item*>( mem );

void SetTracked() {
    --_nUntracked;
}

int Untracked() const {
    return _nUntracked;
}

// This number is perf sensitive. 4k seems like a good tradeoff on my machine.
// The test file is large, 170k.
// Release:		VS2010 gcc(no opt)
//		1k:		4000
//		2k:		4000
//		4k:		3900	21000
//		16k:	5200
//		32k:	4300
//		64k:	4000	21000
// Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
// in private part if ITEMS_PER_BLOCK is private
enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };

union Item {
    Item*   next;
    char    itemData[ITEM_SIZE];
};
struct Block {
    Item items[ITEMS_PER_BLOCK];
};
DynArray< Block*, 10 > _blockPtrs;
Item* _root;

int _currentAllocs;
int _nAllocs;
int _maxAllocs;
int _nUntracked;

If you return 'true' from a Visit method, recursive parsing will continue. If you return
false, <b>no children of this node or its siblings</b> will be visited.

All flavors of Visit methods have a default implementation that returns 'true' (continue
visiting). You need to only override methods that are interesting to you.

Generally Accept() is called on the XMLDocument, although all nodes support visiting.

You should never change the document from a callback.

@sa XMLNode::Accept()

/// Visit a document.
virtual bool VisitEnter( const XMLDocument& /*doc*/ )			{
    return true;
}
/// Visit a document.
virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
    return true;
}

/// Visit an element.
virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ )	{
    return true;
}
/// Visit an element.
virtual bool VisitExit( const XMLElement& /*element*/ )			{
    return true;
}

/// Visit a declaration.
virtual bool Visit( const XMLDeclaration& /*declaration*/ )		{
    return true;
}
/// Visit a text node.
virtual bool Visit( const XMLText& /*text*/ )					{
    return true;
}
/// Visit a comment node.
virtual bool Visit( const XMLComment& /*comment*/ )				{
    return true;
}
/// Visit an unknown node.
virtual bool Visit( const XMLUnknown& /*unknown*/ )				{
    return true;
}

XML_ERROR_COUNT

    while( IsWhiteSpace(*p) ) {
        if (curLineNumPtr && *p == '\n') {
            ++(*curLineNumPtr);
        }
        ++p;
    }
    TIXMLASSERT( p );
    return p;
}
static char* SkipWhiteSpace( char* p, int* curLineNumPtr )				{
    return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p), curLineNumPtr ) );
}

// Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
// correct, but simple, and usually works.
static bool IsWhiteSpace( char p )					{
    return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
}

inline static bool IsNameStartChar( unsigned char ch ) {
    if ( ch >= 128 ) {
        // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
        return true;
    }
    if ( isalpha( ch ) ) {
        return true;
    }
    return ch == ':' || ch == '_';
}

inline static bool IsNameChar( unsigned char ch ) {
    return IsNameStartChar( ch )
           || isdigit( ch )
           || ch == '.'
           || ch == '-';
}

inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
    if ( p == q ) {
        return true;
    }
    TIXMLASSERT( p );
    TIXMLASSERT( q );
    TIXMLASSERT( nChar >= 0 );
    return strncmp( p, q, nChar ) == 0;
}

inline static bool IsUTF8Continuation( char p ) {
    return ( p & 0x80 ) != 0;
}

static const char* ReadBOM( const char* p, bool* hasBOM );
// p is the starting location,
// the UTF-8 value of the entity will be placed in value, and length filled in.
static const char* GetCharacterRef( const char* p, char* value, int* length );
static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );

// converts primitive types to strings
static void ToStr( int v, char* buffer, int bufferSize );
static void ToStr( unsigned v, char* buffer, int bufferSize );
static void ToStr( bool v, char* buffer, int bufferSize );
static void ToStr( float v, char* buffer, int bufferSize );
static void ToStr( double v, char* buffer, int bufferSize );
static void ToStr(int64_t v, char* buffer, int bufferSize);

// converts strings to primitive types
static bool	ToInt( const char* str, int* value );
static bool ToUnsigned( const char* str, unsigned* value );
static bool	ToBool( const char* str, bool* value );
static bool	ToFloat( const char* str, float* value );
static bool ToDouble( const char* str, double* value );
static bool ToInt64(const char* str, int64_t* value);

// Changes what is serialized for a boolean value.
// Default to "true" and "false". Shouldn't be changed
// unless you have a special testing or compatibility need.
// Be careful: static, global, & not thread safe.
// Be sure to set static const memory as parameters.
static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);

A XMLDocument allocates memory for all its Nodes.
When the XMLDocument gets deleted, all its Nodes
will also be deleted.

@verbatim
A Document can contain:	Element	(container or leaf)
						Comment (leaf)
						Unknown (leaf)
						Declaration( leaf )

An Element can contain:	Element (container or leaf)
						Text	(leaf)
						Attributes (not on tree)
						Comment (leaf)
						Unknown (leaf)

@endverbatim

/// Get the XMLDocument that owns this XMLNode.
const XMLDocument* GetDocument() const	{
    TIXMLASSERT( _document );
    return _document;
}
/// Get the XMLDocument that owns this XMLNode.
XMLDocument* GetDocument()				{
    TIXMLASSERT( _document );
    return _document;
}

/// Safely cast to an Element, or null.
virtual XMLElement*		ToElement()		{
    return 0;
}
/// Safely cast to Text, or null.
virtual XMLText*		ToText()		{
    return 0;
}
/// Safely cast to a Comment, or null.
virtual XMLComment*		ToComment()		{
    return 0;
}
/// Safely cast to a Document, or null.
virtual XMLDocument*	ToDocument()	{
    return 0;
}
/// Safely cast to a Declaration, or null.
virtual XMLDeclaration*	ToDeclaration()	{
    return 0;
}
/// Safely cast to an Unknown, or null.
virtual XMLUnknown*		ToUnknown()		{
    return 0;
}

virtual const XMLElement*		ToElement() const		{
    return 0;
}
virtual const XMLText*			ToText() const			{
    return 0;
}
virtual const XMLComment*		ToComment() const		{
    return 0;
}
virtual const XMLDocument*		ToDocument() const		{
    return 0;
}
virtual const XMLDeclaration*	ToDeclaration() const	{
    return 0;
}
virtual const XMLUnknown*		ToUnknown() const		{
    return 0;
}

/** The meaning of 'value' changes for the specific type.
	@verbatim
	Document:	empty (NULL is returned, not an empty string)
	Element:	name of the element
	Comment:	the comment text
	Unknown:	the tag contents
	Text:		the text string
	@endverbatim
*/
const char* Value() const;

/** Set the Value of an XML node.
	@sa Value()
*/
void SetValue( const char* val, bool staticMem=false );

/// Gets the line number the node is in, if the document was parsed from a file.
int GetLineNum() const { return _parseLineNum; }

/// Get the parent of this node on the DOM.
const XMLNode*	Parent() const			{
    return _parent;
}

XMLNode* Parent()						{
    return _parent;
}

/// Returns true if this node has no children.
bool NoChildren() const					{
    return !_firstChild;
}

/// Get the first child node, or null if none exists.
const XMLNode*  FirstChild() const		{
    return _firstChild;
}

XMLNode*		FirstChild()			{
    return _firstChild;
}

/** Get the first child element, or optionally the first child
    element with the specified name.
*/
const XMLElement* FirstChildElement( const char* name = 0 ) const;

XMLElement* FirstChildElement( const char* name = 0 )	{
    return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
}

/// Get the last child node, or null if none exists.
const XMLNode*	LastChild() const						{
    return _lastChild;
}

XMLNode*		LastChild()								{
    return _lastChild;
}

/** Get the last child element or optionally the last child
    element with the specified name.
*/
const XMLElement* LastChildElement( const char* name = 0 ) const;

XMLElement* LastChildElement( const char* name = 0 )	{
    return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
}

/// Get the previous (left) sibling node of this node.
const XMLNode*	PreviousSibling() const					{
    return _prev;
}

XMLNode*	PreviousSibling()							{
    return _prev;
}

/// Get the previous (left) sibling element of this node, with an optionally supplied name.
const XMLElement*	PreviousSiblingElement( const char* name = 0 ) const ;

XMLElement*	PreviousSiblingElement( const char* name = 0 ) {
    return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
}

/// Get the next (right) sibling node of this node.
const XMLNode*	NextSibling() const						{
    return _next;
}

XMLNode*	NextSibling()								{
    return _next;
}

/// Get the next (right) sibling element of this node, with an optionally supplied name.
const XMLElement*	NextSiblingElement( const char* name = 0 ) const;

XMLElement*	NextSiblingElement( const char* name = 0 )	{
    return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
}

/**
	Add a child node as the last (right) child.
	If the child node is already part of the document,
	it is moved from its old location to the new location.
	Returns the addThis argument or 0 if the node does not
	belong to the same document.
*/
XMLNode* InsertEndChild( XMLNode* addThis );

XMLNode* LinkEndChild( XMLNode* addThis )	{
    return InsertEndChild( addThis );
}
/**
	Add a child node as the first (left) child.
	If the child node is already part of the document,
	it is moved from its old location to the new location.
	Returns the addThis argument or 0 if the node does not
	belong to the same document.
*/
XMLNode* InsertFirstChild( XMLNode* addThis );
/**
	Add a node after the specified child node.
	If the child node is already part of the document,
	it is moved from its old location to the new location.
	Returns the addThis argument or 0 if the afterThis node
	is not a child of this node, or if the node does not
	belong to the same document.
*/
XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );

/**
	Delete all the children of this node.
*/
void DeleteChildren();

/**
	Delete a child of this node.
*/
void DeleteChild( XMLNode* node );

/**
	Make a copy of this node, but not its children.
	You may pass in a Document pointer that will be
	the owner of the new Node. If the 'document' is
	null, then the node returned will be allocated
	from the current Document. (this->GetDocument())

	Note: if called on a XMLDocument, this will return null.
*/
virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;

/**
	Make a copy of this node and all its children.

	If the 'target' is null, then the nodes will
	be allocated in the current document. If 'target'
    is specified, the memory will be allocated is the
    specified XMLDocument.

	NOTE: This is probably not the correct tool to
	copy a document, since XMLDocuments can have multiple
	top level XMLNodes. You probably want to use
    XMLDocument::DeepCopy()
*/
XMLNode* DeepClone( XMLDocument* target ) const;

/**
	Test if 2 nodes are the same, but don't test children.
	The 2 nodes do not need to be in the same Document.

	Note: if called on a XMLDocument, this will return false.
*/
virtual bool ShallowEqual( const XMLNode* compare ) const = 0;

/** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
	XML tree will be conditionally visited and the host will be called back
	via the XMLVisitor interface.

	This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
	the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
	interface versus any other.)

	The interface has been based on ideas from:

	- http://www.saxproject.org/
	- http://c2.com/cgi/wiki?HierarchicalVisitorPattern

	Which are both good references for "visiting".

	An example of using Accept():
	@verbatim
	XMLPrinter printer;
	tinyxmlDoc.Accept( &printer );
	const char* xmlcstr = printer.CStr();
	@endverbatim
*/
virtual bool Accept( XMLVisitor* visitor ) const = 0;

/**
	Set user data into the XMLNode. TinyXML-2 in
	no way processes or interprets user data.
	It is initially 0.
*/
void SetUserData(void* userData)	{ _userData = userData; }

/**
	Get user data set into the XMLNode. TinyXML-2 in
	no way processes or interprets user data.
	It is initially 0.
*/
void* GetUserData() const			{ return _userData; }

virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);

XMLDocument*	_document;
XMLNode*		_parent;
mutable StrPair	_value;
int             _parseLineNum;

XMLNode*		_firstChild;
XMLNode*		_lastChild;

XMLNode*		_prev;
XMLNode*		_next;

void*			_userData;

XMLNode( const XMLNode& );	// not supported
XMLNode& operator=( const XMLNode& );	// not supported

Note that a text node can have child element nodes, for example:
@verbatim
<root>This is <b>bold</b></root>
@endverbatim

A text node can have 2 ways to output the next. "normal" output
and CDATA. It will default to the mode it was parsed from the XML file and
you generally want to leave it alone, but you can change the output mode with
SetCData() and query it with CData().

virtual XMLText* ToText()			{
    return this;
}
virtual const XMLText* ToText() const	{
    return this;
}

/// Declare whether this should be CDATA or standard text.
void SetCData( bool isCData )			{
    _isCData = isCData;
}
/// Returns true if this is a CDATA text element.
bool CData() const						{
    return _isCData;
}

virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;

char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );

XMLText( const XMLText& );	// not supported
XMLText& operator=( const XMLText& );	// not supported

virtual bool Accept( XMLVisitor* visitor ) const;

virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;

char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);

TinyXML-2 will happily read or write files without a declaration,
however.

The text of the declaration isn't interpreted. It is parsed
and written as a string.

virtual bool Accept( XMLVisitor* visitor ) const;

virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;

char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );

DTD tags get thrown into XMLUnknowns.

virtual bool Accept( XMLVisitor* visitor ) const;

virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;

char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );

@note The attributes are not XMLNodes. You may only query the
Next() attribute in a list.

/// The value of the attribute.
const char* Value() const;

/// Gets the line number the attribute is in, if the document was parsed from a file.
int GetLineNum() const { return _parseLineNum; }

/// The next attribute in the list.
const XMLAttribute* Next() const {
    return _next;
}

/** IntValue interprets the attribute as an integer, and returns the value.
    If the value isn't an integer, 0 will be returned. There is no error checking;
	use QueryIntValue() if you need error checking.
*/
int	IntValue() const {
	int i = 0;
	QueryIntValue(&i);
	return i;
}

int64_t Int64Value() const {
	int64_t i = 0;
	QueryInt64Value(&i);
	return i;
}

/// Query as an unsigned integer. See IntValue()
unsigned UnsignedValue() const			{
    unsigned i=0;
    QueryUnsignedValue( &i );
    return i;
}
/// Query as a boolean. See IntValue()
bool	 BoolValue() const				{
    bool b=false;
    QueryBoolValue( &b );
    return b;
}
/// Query as a double. See IntValue()
double 	 DoubleValue() const			{
    double d=0;
    QueryDoubleValue( &d );
    return d;
}
/// Query as a float. See IntValue()
float	 FloatValue() const				{
    float f=0;
    QueryFloatValue( &f );
    return f;
}

/** QueryIntValue interprets the attribute as an integer, and returns the value
	in the provided parameter. The function will return XML_SUCCESS on success,
	and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
*/
XMLError QueryIntValue( int* value ) const;
/// See QueryIntValue
XMLError QueryUnsignedValue( unsigned int* value ) const;
/// See QueryIntValue
XMLError QueryInt64Value(int64_t* value) const;
/// See QueryIntValue
XMLError QueryBoolValue( bool* value ) const;
/// See QueryIntValue
XMLError QueryDoubleValue( double* value ) const;
/// See QueryIntValue
XMLError QueryFloatValue( float* value ) const;

/// Set the attribute to a string value.
void SetAttribute( const char* value );
/// Set the attribute to value.
void SetAttribute( int value );
/// Set the attribute to value.
void SetAttribute( unsigned value );
/// Set the attribute to value.
void SetAttribute(int64_t value);
/// Set the attribute to value.
void SetAttribute( bool value );
/// Set the attribute to value.
void SetAttribute( double value );
/// Set the attribute to value.
void SetAttribute( float value );

XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
virtual ~XMLAttribute()	{}

XMLAttribute( const XMLAttribute& );	// not supported
void operator=( const XMLAttribute& );	// not supported
void SetName( const char* name );

char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );

mutable StrPair _name;
mutable StrPair _value;
int             _parseLineNum;
XMLAttribute*   _next;
MemPool*        _memPool;

virtual XMLElement* ToElement()				{
    return this;
}
virtual const XMLElement* ToElement() const {
    return this;
}
virtual bool Accept( XMLVisitor* visitor ) const;

/** Given an attribute name, Attribute() returns the value
	for the attribute of that name, or null if none
	exists. For example:

	@verbatim
	const char* value = ele->Attribute( "foo" );
	@endverbatim

	The 'value' parameter is normally null. However, if specified,
	the attribute will only be returned if the 'name' and 'value'
	match. This allow you to write code:

	@verbatim
	if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
	@endverbatim

	rather than:
	@verbatim
	if ( ele->Attribute( "foo" ) ) {
		if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
	}
	@endverbatim
*/
const char* Attribute( const char* name, const char* value=0 ) const;

/** Given an attribute name, IntAttribute() returns the value
	of the attribute interpreted as an integer. The default
    value will be returned if the attribute isn't present,
    or if there is an error. (For a method with error
	checking, see QueryIntAttribute()).
*/
int IntAttribute(const char* name, int defaultValue = 0) const;
/// See IntAttribute()
unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
/// See IntAttribute()
int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
/// See IntAttribute()
bool BoolAttribute(const char* name, bool defaultValue = false) const;
/// See IntAttribute()
double DoubleAttribute(const char* name, double defaultValue = 0) const;
/// See IntAttribute()
float FloatAttribute(const char* name, float defaultValue = 0) const;

/** Given an attribute name, QueryIntAttribute() returns
	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
	can't be performed, or XML_NO_ATTRIBUTE if the attribute
	doesn't exist. If successful, the result of the conversion
	will be written to 'value'. If not successful, nothing will
	be written to 'value'. This allows you to provide default
	value:

	@verbatim
	int value = 10;
	QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
	@endverbatim
*/
XMLError QueryIntAttribute( const char* name, int* value ) const				{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return XML_NO_ATTRIBUTE;
    }
    return a->QueryIntValue( value );
}

/// See QueryIntAttribute()
XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return XML_NO_ATTRIBUTE;
    }
    return a->QueryUnsignedValue( value );
}

/// See QueryIntAttribute()
XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
	const XMLAttribute* a = FindAttribute(name);
	if (!a) {
		return XML_NO_ATTRIBUTE;
	}
	return a->QueryInt64Value(value);
}

/// See QueryIntAttribute()
XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return XML_NO_ATTRIBUTE;
    }
    return a->QueryBoolValue( value );
}
/// See QueryIntAttribute()
XMLError QueryDoubleAttribute( const char* name, double* value ) const			{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return XML_NO_ATTRIBUTE;
    }
    return a->QueryDoubleValue( value );
}
/// See QueryIntAttribute()
XMLError QueryFloatAttribute( const char* name, float* value ) const			{
    const XMLAttribute* a = FindAttribute( name );
    if ( !a ) {
        return XML_NO_ATTRIBUTE;
    }
    return a->QueryFloatValue( value );
}

/// See QueryIntAttribute()
XMLError QueryStringAttribute(const char* name, const char** value) const {
	const XMLAttribute* a = FindAttribute(name);
	if (!a) {
		return XML_NO_ATTRIBUTE;
	}
	*value = a->Value();
	return XML_SUCCESS;
}



/** Given an attribute name, QueryAttribute() returns
	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
	can't be performed, or XML_NO_ATTRIBUTE if the attribute
	doesn't exist. It is overloaded for the primitive types,
	and is a generally more convenient replacement of
	QueryIntAttribute() and related functions.

	If successful, the result of the conversion
	will be written to 'value'. If not successful, nothing will
	be written to 'value'. This allows you to provide default
	value:

	@verbatim
	int value = 10;
	QueryAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
	@endverbatim
*/
XMLError QueryAttribute( const char* name, int* value ) const {
	return QueryIntAttribute( name, value );
}

XMLError QueryAttribute( const char* name, unsigned int* value ) const {
	return QueryUnsignedAttribute( name, value );
}

XMLError QueryAttribute(const char* name, int64_t* value) const {
	return QueryInt64Attribute(name, value);
}

XMLError QueryAttribute( const char* name, bool* value ) const {
	return QueryBoolAttribute( name, value );
}

XMLError QueryAttribute( const char* name, double* value ) const {
	return QueryDoubleAttribute( name, value );
}

XMLError QueryAttribute( const char* name, float* value ) const {
	return QueryFloatAttribute( name, value );
}

/// Sets the named attribute to value.
void SetAttribute( const char* name, const char* value )	{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}
/// Sets the named attribute to value.
void SetAttribute( const char* name, int value )			{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}
/// Sets the named attribute to value.
void SetAttribute( const char* name, unsigned value )		{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}

/// Sets the named attribute to value.
void SetAttribute(const char* name, int64_t value) {
	XMLAttribute* a = FindOrCreateAttribute(name);
	a->SetAttribute(value);
}

/// Sets the named attribute to value.
void SetAttribute( const char* name, bool value )			{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}
/// Sets the named attribute to value.
void SetAttribute( const char* name, double value )		{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}
/// Sets the named attribute to value.
void SetAttribute( const char* name, float value )		{
    XMLAttribute* a = FindOrCreateAttribute( name );
    a->SetAttribute( value );
}

/**
	Delete an attribute.
*/
void DeleteAttribute( const char* name );

/// Return the first attribute in the list.
const XMLAttribute* FirstAttribute() const {
    return _rootAttribute;
}
/// Query a specific attribute in the list.
const XMLAttribute* FindAttribute( const char* name ) const;

/** Convenience function for easy access to the text inside an element. Although easy
	and concise, GetText() is limited compared to getting the XMLText child
	and accessing it directly.

	If the first child of 'this' is a XMLText, the GetText()
	returns the character string of the Text node, else null is returned.

	This is a convenient method for getting the text of simple contained text:
	@verbatim
	<foo>This is text</foo>
		const char* str = fooElement->GetText();
	@endverbatim

	'str' will be a pointer to "This is text".

	Note that this function can be misleading. If the element foo was created from
	this XML:
	@verbatim
		<foo><b>This is text</b></foo>
	@endverbatim

	then the value of str would be null. The first child node isn't a text node, it is
	another element. From this XML:
	@verbatim
		<foo>This is <b>text</b></foo>
	@endverbatim
	GetText() will return "This is ".
*/
const char* GetText() const;

/** Convenience function for easy access to the text inside an element. Although easy
	and concise, SetText() is limited compared to creating an XMLText child
	and mutating it directly.

	If the first child of 'this' is a XMLText, SetText() sets its value to
	the given string, otherwise it will create a first child that is an XMLText.

	This is a convenient method for setting the text of simple contained text:
	@verbatim
	<foo>This is text</foo>
		fooElement->SetText( "Hullaballoo!" );
 	<foo>Hullaballoo!</foo>
	@endverbatim

	Note that this function can be misleading. If the element foo was created from
	this XML:
	@verbatim
		<foo><b>This is text</b></foo>
	@endverbatim

	then it will not change "This is text", but rather prefix it with a text element:
	@verbatim
		<foo>Hullaballoo!<b>This is text</b></foo>
	@endverbatim

	For this XML:
	@verbatim
		<foo />
	@endverbatim
	SetText() will generate
	@verbatim
		<foo>Hullaballoo!</foo>
	@endverbatim
*/
void SetText( const char* inText );
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( int value );
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( unsigned value );
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText(int64_t value);
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( bool value );
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( double value );
/// Convenience method for setting text inside an element. See SetText() for important limitations.
void SetText( float value );

/**
	Convenience method to query the value of a child text node. This is probably best
	shown by example. Given you have a document is this form:
	@verbatim
		<point>
			<x>1</x>
			<y>1.4</y>
		</point>
	@endverbatim

	The QueryIntText() and similar functions provide a safe and easier way to get to the
	"value" of x and y.

	@verbatim
		int x = 0;
		float y = 0;	// types of x and y are contrived for example
		const XMLElement* xElement = pointElement->FirstChildElement( "x" );
		const XMLElement* yElement = pointElement->FirstChildElement( "y" );
		xElement->QueryIntText( &x );
		yElement->QueryFloatText( &y );
	@endverbatim

	@returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
			 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.

*/
XMLError QueryIntText( int* ival ) const;
/// See QueryIntText()
XMLError QueryUnsignedText( unsigned* uval ) const;
/// See QueryIntText()
XMLError QueryInt64Text(int64_t* uval) const;
/// See QueryIntText()
XMLError QueryBoolText( bool* bval ) const;
/// See QueryIntText()
XMLError QueryDoubleText( double* dval ) const;
/// See QueryIntText()
XMLError QueryFloatText( float* fval ) const;

int IntText(int defaultValue = 0) const;

/// See QueryIntText()
unsigned UnsignedText(unsigned defaultValue = 0) const;
/// See QueryIntText()
int64_t Int64Text(int64_t defaultValue = 0) const;
/// See QueryIntText()
bool BoolText(bool defaultValue = false) const;
/// See QueryIntText()
double DoubleText(double defaultValue = 0) const;
/// See QueryIntText()
float FloatText(float defaultValue = 0) const;

// internal:
enum ElementClosingType {
    OPEN,		// <foo>
    CLOSED,		// <foo/>
    CLOSING		// </foo>
};
ElementClosingType ClosingType() const {
    return _closingType;
}
virtual XMLNode* ShallowClone( XMLDocument* document ) const;
virtual bool ShallowEqual( const XMLNode* compare ) const;

XMLAttribute* FindOrCreateAttribute( const char* name );
char* ParseAttributes( char* p, int* curLineNumPtr );
static void DeleteAttribute( XMLAttribute* attribute );
XMLAttribute* CreateAttribute();

enum { BUF_SIZE = 200 };
ElementClosingType _closingType;
// The attribute list is ordered; there is no 'lastAttribute'
// because the list needs to be scanned for dupes before adding
// a new attribute.
XMLAttribute* _rootAttribute;

virtual XMLDocument* ToDocument()				{
    TIXMLASSERT( this == _document );
    return this;
}
virtual const XMLDocument* ToDocument() const	{
    TIXMLASSERT( this == _document );
    return this;
}

/**
	Parse an XML file from a character string.
	Returns XML_SUCCESS (0) on success, or
	an errorID.

	You may optionally pass in the 'nBytes', which is
	the number of bytes which will be parsed. If not
	specified, TinyXML-2 will assume 'xml' points to a
	null terminated string.
*/
XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );

/**
	Load an XML file from disk.
	Returns XML_SUCCESS (0) on success, or
	an errorID.
*/
XMLError LoadFile( const char* filename );

/**
	Load an XML file from disk. You are responsible
	for providing and closing the FILE*.

    NOTE: The file should be opened as binary ("rb")
    not text in order for TinyXML-2 to correctly
    do newline normalization.

	Returns XML_SUCCESS (0) on success, or
	an errorID.
*/
XMLError LoadFile( FILE* );

/**
	Save the XML file to disk.
	Returns XML_SUCCESS (0) on success, or
	an errorID.
*/
XMLError SaveFile( const char* filename, bool compact = false );

/**
	Save the XML file to disk. You are responsible
	for providing and closing the FILE*.

	Returns XML_SUCCESS (0) on success, or
	an errorID.
*/
XMLError SaveFile( FILE* fp, bool compact = false );

bool ProcessEntities() const		{
    return _processEntities;
}
Whitespace WhitespaceMode() const	{
    return _whitespaceMode;
}

/**
	Returns true if this document has a leading Byte Order Mark of UTF8.
*/
bool HasBOM() const {
    return _writeBOM;
}
/** Sets whether to write the BOM when writing the file.
*/
void SetBOM( bool useBOM ) {
    _writeBOM = useBOM;
}

/** Return the root element of DOM. Equivalent to FirstChildElement().
    To get the first node, use FirstChild().
*/
XMLElement* RootElement()				{
    return FirstChildElement();
}
const XMLElement* RootElement() const	{
    return FirstChildElement();
}

/** Print the Document. If the Printer is not provided, it will
    print to stdout. If you provide Printer, this can print to a file:
	@verbatim
	XMLPrinter printer( fp );
	doc.Print( &printer );
	@endverbatim

	Or you can use a printer to print to memory:
	@verbatim
	XMLPrinter printer;
	doc.Print( &printer );
	// printer.CStr() has a const char* to the XML
	@endverbatim
*/
void Print( XMLPrinter* streamer=0 ) const;
virtual bool Accept( XMLVisitor* visitor ) const;

/**
	Create a new Element associated with
	this Document. The memory for the Element
	is managed by the Document.
*/
XMLElement* NewElement( const char* name );
/**
	Create a new Comment associated with
	this Document. The memory for the Comment
	is managed by the Document.
*/
XMLComment* NewComment( const char* comment );
/**
	Create a new Text associated with
	this Document. The memory for the Text
	is managed by the Document.
*/
XMLText* NewText( const char* text );
/**
	Create a new Declaration associated with
	this Document. The memory for the object
	is managed by the Document.

	If the 'text' param is null, the standard
	declaration is used.:
	@verbatim
		<?xml version="1.0" encoding="UTF-8"?>
	@endverbatim
*/
XMLDeclaration* NewDeclaration( const char* text=0 );
/**
	Create a new Unknown associated with
	this Document. The memory for the object
	is managed by the Document.
*/
XMLUnknown* NewUnknown( const char* text );

/**
	Delete a node associated with this document.
	It will be unlinked from the DOM.
*/
void DeleteNode( XMLNode* node );

void ClearError() {
    SetError(XML_SUCCESS, 0, 0);
}

/// Return true if there was an error parsing the document.
bool Error() const {
    return _errorID != XML_SUCCESS;
}
/// Return the errorID.
XMLError  ErrorID() const {
    return _errorID;
}
const char* ErrorName() const;
static const char* ErrorIDToName(XMLError errorID);

/** Returns a "long form" error description. A hopefully helpful
    diagnostic with location, line number, and/or additional info.
*/
const char* ErrorStr() const;

/// A (trivial) utility function that prints the ErrorStr() to stdout.
void PrintError() const;

/// Return the line where the error occurred, or zero if unknown.
int ErrorLineNum() const
{
    return _errorLineNum;
}

/// Clear the document, resetting it to the initial state.
void Clear();

/**
	Copies this document to a target document.
	The target will be completely cleared before the copy.
	If you want to copy a sub-tree, see XMLNode::DeepClone().

	NOTE: that the 'target' must be non-null.
*/
void DeepCopy(XMLDocument* target) const;

// internal
char* Identify( char* p, XMLNode** node );

// internal
void MarkInUse(XMLNode*);

virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const	{
    return 0;
}
virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const	{
    return false;
}

bool			_writeBOM;
bool			_processEntities;
XMLError		_errorID;
Whitespace		_whitespaceMode;
mutable StrPair	_errorStr;
int             _errorLineNum;
char*			_charBuffer;
int				_parseCurLineNum;
int				_parsingDepth;
// Memory tracking does add some overhead.
// However, the code assumes that you don't
// have a bunch of unlinked nodes around.
// Therefore it takes less memory to track
// in the document vs. a linked list in the XMLNode,
// and the performance is the same.
DynArray<XMLNode*, 10> _unlinked;

MemPoolT< sizeof(XMLElement) >	 _elementPool;
MemPoolT< sizeof(XMLAttribute) > _attributePool;
MemPoolT< sizeof(XMLText) >		 _textPool;
MemPoolT< sizeof(XMLComment) >	 _commentPool;

static const char* _errorNames[XML_ERROR_COUNT];

void Parse();

void SetError( XMLError error, int lineNum, const char* format, ... );

// Something of an obvious security hole, once it was discovered.
// Either an ill-formed XML or an excessively deep one can overflow
// the stack. Track stack depth, and error out if needed.
class DepthTracker {
public:
	explicit DepthTracker(XMLDocument * document) {
		this->_document = document;
		document->PushDepth();
	}
	~DepthTracker() {
		_document->PopDepth();
	}
private:
	XMLDocument * _document;
};
void PushDepth();
void PopDepth();

template<class NodeType, int PoolElementSize>
NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );

_unlinked.Push(returnNode);
return returnNode;

Take an example:
@verbatim
<Document>
	<Element attributeA = "valueA">
		<Child attributeB = "value1" />
		<Child attributeB = "value2" />
	</Element>
</Document>
@endverbatim

Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
easy to write a *lot* of code that looks like:

@verbatim
XMLElement* root = document.FirstChildElement( "Document" );
if ( root )
{
	XMLElement* element = root->FirstChildElement( "Element" );
	if ( element )
	{
		XMLElement* child = element->FirstChildElement( "Child" );
		if ( child )
		{
			XMLElement* child2 = child->NextSiblingElement( "Child" );
			if ( child2 )
			{
				// Finally do something useful.
@endverbatim

And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
of such code. A XMLHandle checks for null pointers so it is perfectly safe
and correct to use:

@verbatim
XMLHandle docHandle( &document );
XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
if ( child2 )
{
	// do something useful
@endverbatim

Which is MUCH more concise and useful.

It is also safe to copy handles - internally they are nothing more than node pointers.
@verbatim
XMLHandle handleCopy = handle;
@endverbatim

See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.

/// Get the first child of this handle.
XMLHandle FirstChild() 													{
    return XMLHandle( _node ? _node->FirstChild() : 0 );
}
/// Get the first child element of this handle.
XMLHandle FirstChildElement( const char* name = 0 )						{
    return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
}
/// Get the last child of this handle.
XMLHandle LastChild()													{
    return XMLHandle( _node ? _node->LastChild() : 0 );
}
/// Get the last child element of this handle.
XMLHandle LastChildElement( const char* name = 0 )						{
    return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
}
/// Get the previous sibling of this handle.
XMLHandle PreviousSibling()												{
    return XMLHandle( _node ? _node->PreviousSibling() : 0 );
}
/// Get the previous sibling element of this handle.
XMLHandle PreviousSiblingElement( const char* name = 0 )				{
    return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
}
/// Get the next sibling of this handle.
XMLHandle NextSibling()													{
    return XMLHandle( _node ? _node->NextSibling() : 0 );
}
/// Get the next sibling element of this handle.
XMLHandle NextSiblingElement( const char* name = 0 )					{
    return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
}

/// Safe cast to XMLNode. This can return null.
XMLNode* ToNode()							{
    return _node;
}
/// Safe cast to XMLElement. This can return null.
XMLElement* ToElement() 					{
    return ( _node ? _node->ToElement() : 0 );
}
/// Safe cast to XMLText. This can return null.
XMLText* ToText() 							{
    return ( _node ? _node->ToText() : 0 );
}
/// Safe cast to XMLUnknown. This can return null.
XMLUnknown* ToUnknown() 					{
    return ( _node ? _node->ToUnknown() : 0 );
}
/// Safe cast to XMLDeclaration. This can return null.
XMLDeclaration* ToDeclaration() 			{
    return ( _node ? _node->ToDeclaration() : 0 );
}

XMLConstHandle& operator=( const XMLConstHandle& ref )							{
    _node = ref._node;
    return *this;
}

const XMLConstHandle FirstChild() const											{
    return XMLConstHandle( _node ? _node->FirstChild() : 0 );
}
const XMLConstHandle FirstChildElement( const char* name = 0 ) const				{
    return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
}
const XMLConstHandle LastChild()	const										{
    return XMLConstHandle( _node ? _node->LastChild() : 0 );
}
const XMLConstHandle LastChildElement( const char* name = 0 ) const				{
    return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
}
const XMLConstHandle PreviousSibling() const									{
    return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
}
const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const		{
    return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
}
const XMLConstHandle NextSibling() const										{
    return XMLConstHandle( _node ? _node->NextSibling() : 0 );
}
const XMLConstHandle NextSiblingElement( const char* name = 0 ) const			{
    return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
}


const XMLNode* ToNode() const				{
    return _node;
}
const XMLElement* ToElement() const			{
    return ( _node ? _node->ToElement() : 0 );
}
const XMLText* ToText() const				{
    return ( _node ? _node->ToText() : 0 );
}
const XMLUnknown* ToUnknown() const			{
    return ( _node ? _node->ToUnknown() : 0 );
}
const XMLDeclaration* ToDeclaration() const	{
    return ( _node ? _node->ToDeclaration() : 0 );
}

It can:
-# Print to memory.
-# Print to a file you provide.
-# Print XML without a XMLDocument.

Print to Memory

@verbatim
XMLPrinter printer;
doc.Print( &printer );
SomeFunction( printer.CStr() );
@endverbatim

Print to a File

You provide the file pointer.
@verbatim
XMLPrinter printer( fp );
doc.Print( &printer );
@endverbatim

Print without a XMLDocument

When loading, an XML parser is very useful. However, sometimes
when saving, it just gets in the way. The code is often set up
for streaming, and constructing the DOM is just overhead.

The Printer supports the streaming case. The following code
prints out a trivially simple XML file without ever creating
an XML document.

@verbatim
XMLPrinter printer( fp );
printer.OpenElement( "foo" );
printer.PushAttribute( "foo", "bar" );
printer.CloseElement();
@endverbatim

/** If streaming, write the BOM and declaration. */
void PushHeader( bool writeBOM, bool writeDeclaration );
/** If streaming, start writing an element.
    The element must be closed with CloseElement()
*/
void OpenElement( const char* name, bool compactMode=false );
/// If streaming, add an attribute to an open element.
void PushAttribute( const char* name, const char* value );
void PushAttribute( const char* name, int value );
void PushAttribute( const char* name, unsigned value );
void PushAttribute(const char* name, int64_t value);
void PushAttribute( const char* name, bool value );
void PushAttribute( const char* name, double value );
/// If streaming, close the Element.
virtual void CloseElement( bool compactMode=false );

/// Add a text node.
void PushText( const char* text, bool cdata=false );
/// Add a text node from an integer.
void PushText( int value );
/// Add a text node from an unsigned.
void PushText( unsigned value );
/// Add a text node from an unsigned.
void PushText(int64_t value);
/// Add a text node from a bool.
void PushText( bool value );
/// Add a text node from a float.
void PushText( float value );
/// Add a text node from a double.
void PushText( double value );

/// Add a comment
void PushComment( const char* comment );

void PushDeclaration( const char* value );
void PushUnknown( const char* value );

virtual bool VisitEnter( const XMLDocument& /*doc*/ );
virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
    return true;
}

virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
virtual bool VisitExit( const XMLElement& element );

virtual bool Visit( const XMLText& text );
virtual bool Visit( const XMLComment& comment );
virtual bool Visit( const XMLDeclaration& declaration );
virtual bool Visit( const XMLUnknown& unknown );

/**
	If in print to memory mode, return a pointer to
	the XML file in memory.
*/
const char* CStr() const {
    return _buffer.Mem();
}
/**
	If in print to memory mode, return the size
	of the XML file in memory. (Note the size returned
	includes the terminating null.)
*/
int CStrSize() const {
    return _buffer.Size();
}
/**
	If in print to memory mode, reset the buffer to the
	beginning.
*/
void ClearBuffer() {
    _buffer.Clear();
    _buffer.Push(0);
	_firstElement = true;
}

/** Prints out the space before an element. You may override to change
    the space and tabs used. A PrintSpace() override should call Print().
*/
virtual void PrintSpace( int depth );
void Print( const char* format, ... );
void Write( const char* data, size_t size );
inline void Write( const char* data )           { Write( data, strlen( data ) ); }
void Putc( char ch );

void SealElementIfJustOpened();
bool _elementJustOpened;
DynArray< const char*, 10 > _stack;

bool _firstElement;
FILE* _fp;
int _depth;
int _textDepth;
bool _processEntities;
bool _compactMode;

enum {
    ENTITY_RANGE = 64,
    BUF_SIZE = 200
};
bool _entityFlag[ENTITY_RANGE];
bool _restrictedEntityFlag[ENTITY_RANGE];

DynArray< char, 20 > _buffer;

// Prohibit cloning, intentionally not implemented
XMLPrinter( const XMLPrinter& );
XMLPrinter& operator=( const XMLPrinter& );

fp = fopen(fdata, "wb");
write(fp);
fclose(fp);
bool res = signFile(fdata, SignToolPath, FixtureName, WorkerName, sig.value);
if( !res )
{
    beforeExit();
    throw;
}
remove(fdata);
remove(fsig);

return res;

fp = fopen(fdata, "wb");
writeplain(fp);
fclose(fp);
fp = fopen(fsig, "wb");
sig.writeplain(fp);
fclose(fp);

bool res = verifySignature(fdata, fsig, SignToolPath, "GWP_firmware.crt");
if( !res )
{
    beforeExit();
    throw;
}
remove(fdata);
remove(fsig);

return res;

const char* name = nullptr;
uint32_t size = 0;
uint8_t* value = nullptr;
uint8_t* cipher = nullptr;
list<Tnode*> children;

Tnode();
Tnode(char* n, uint32_t s);
Tnode(char* n);
Tnode(char* n, uint32_t s, uint32_t v);
Tnode(char* n, uint32_t s, uint8_t* v);
Tnode(char* n, FILE* fp);
Tnode(char* n, uint32_t s, FILE* fp);
~Tnode(void);

void set(uint32_t s);
void set(uint8_t* buf);
void set(uint32_t s, uint32_t v);
void set(uint32_t s, uint8_t* v);
void set(FILE* fp);
void set(uint32_t s, FILE* fp);

Tnode& operator=(int v);
Tnode& operator=(const char* v);
Tnode& operator=(FILE* fp);
operator uint8_t*(void);
operator uint32_t(void);

void addChild(Tnode* child);
void moveChild(Tnode& node);
uint32_t gsize(void);

void read(uint8_t* buf);
void read(FILE* fp);
void write(uint8_t* buf);
void write(FILE* fp);
void readcipher(uint8_t* buf);
void readcipher(FILE* fp);
void writeplain(FILE* fp);
void writeplain(uint8_t* buf);
void writecipher(uint8_t* buf);
void clearcipher(void);

Tnode* find(const char* n);
void encrypt(const uint8_t* key, const uint8_t* iv, uint32_t ivlen);
void decrypt(const uint8_t* key, const uint8_t* iv, uint32_t ivlen);
void digest(Tnode& hash);
bool verifyDigest(Tnode& hash);
bool sign(Tnode& sig);
bool verify(Tnode& sig);

/// \brief Construct a ConstByteArrayParameter
/// \param data a memory buffer
/// \param size the length of the memory buffer
/// \param deepCopy flag indicating whether the data should be copied
/// \details The deepCopy option is used when the NameValuePairs object can't
///   keep a copy of the data available
ConstByteArrayParameter(const byte *data, size_t size, bool deepCopy = false)
	: m_deepCopy(false), m_data(NULLPTR), m_size(0)
{
	Assign(data, size, deepCopy);
}

/// \brief Construct a ConstByteArrayParameter
/// \tparam T a std::basic_string<char> or std::vector<byte> class
/// \param string a std::basic_string<char> or std::vector<byte> object
/// \param deepCopy flag indicating whether the data should be copied
/// \details The deepCopy option is used when the NameValuePairs object can't
///   keep a copy of the data available
template <class T> ConstByteArrayParameter(const T &string, bool deepCopy = false)
	: m_deepCopy(false), m_data(NULLPTR), m_size(0)
{
	CRYPTOPP_COMPILE_ASSERT(sizeof(typename T::value_type) == 1);
	Assign(reinterpret_cast<const byte *>(&string[0]), string.size(), deepCopy);
}

/// \brief Assign contents from a memory buffer
/// \param data a memory buffer
/// \param size the length of the memory buffer
/// \param deepCopy flag indicating whether the data should be copied
/// \details The deepCopy option is used when the NameValuePairs object can't
///   keep a copy of the data available
void Assign(const byte *data, size_t size, bool deepCopy)
{
	// This fires, which means: no data with a size, or data with no size.
	// CRYPTOPP_ASSERT((data && size) || !(data || size));
	if (deepCopy)
		m_block.Assign(data, size);
	else
	{
		m_data = data;
		m_size = size;
	}
	m_deepCopy = deepCopy;
}

/// \brief Pointer to the first byte in the memory block
const byte *begin() const {return m_deepCopy ? m_block.begin() : m_data;}
/// \brief Pointer beyond the last byte in the memory block
const byte *end() const {return m_deepCopy ? m_block.end() : m_data + m_size;}
/// \brief Length of the memory block
size_t size() const {return m_deepCopy ? m_block.size() : m_size;}

/// \brief Construct a ByteArrayParameter
/// \param block a SecByteBlock
ByteArrayParameter(SecByteBlock &block)
	: m_data(block.begin()), m_size(block.size()) {}

/// \brief Pointer to the first byte in the memory block
byte *begin() const {return m_data;}
/// \brief Pointer beyond the last byte in the memory block
byte *end() const {return m_data + m_size;}
/// \brief Length of the memory block
size_t size() const {return m_size;}

bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;

	if (!m_found && strncmp(m_name, "ThisPointer:", 12) == 0 && strcmp(m_name+12, typeid(T).name()) == 0)
	{
		NameValuePairs::ThrowIfTypeMismatch(m_name, typeid(T *), *m_valueType);
		*reinterpret_cast<const T **>(pValue) = pObject;
		m_found = true;
		return;
	}

	if (!m_found && searchFirst)
		m_found = searchFirst->GetVoidValue(m_name, valueType, pValue);

	if (!m_found && typeid(T) != typeid(BASE))
		m_found = pObject->BASE::GetVoidValue(m_name, valueType, pValue);
}

operator bool() const {return m_found;}

template <class R>
GetValueHelperClass<T,BASE> & operator()(const char *name, const R & (T::*pm)() const)
{
	if (m_getValueNames)
		(*reinterpret_cast<std::string *>(m_pValue) += name) += ";";
	if (!m_found && strcmp(name, m_name) == 0)
	{
		NameValuePairs::ThrowIfTypeMismatch(name, typeid(R), *m_valueType);
		*reinterpret_cast<R *>(m_pValue) = (m_pObject->*pm)();
		m_found = true;
	}
	return *this;
}

GetValueHelperClass<T,BASE> &Assignable()
{

template <class R>
AssignFromHelperClass & operator()(const char *name, void (T::*pm)(const R&))
{
	if (!m_done)
	{
		R value;
		if (!m_source.GetValue(name, value))
			throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name + "'");
		(m_pObject->*pm)(value);
	}
	return *this;
}

template <class R, class S>
AssignFromHelperClass & operator()(const char *name1, const char *name2, void (T::*pm)(const R&, const S&))
{
	if (!m_done)
	{
		R value1;
		if (!m_source.GetValue(name1, value1))
			throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name1 + "'");
		S value2;
		if (!m_source.GetValue(name2, value2))
			throw InvalidArgument(std::string(typeid(T).name()) + ": Missing required parameter '" + name2 + "'");
		(m_pObject->*pm)(value1, value2);
	}
	return *this;
}

virtual ~AlgorithmParametersBase() CRYPTOPP_THROW
{

// this is actually a move, not a copy
AlgorithmParametersBase(const AlgorithmParametersBase &x)
	: m_name(x.m_name), m_throwIfNotUsed(x.m_throwIfNotUsed), m_used(x.m_used)
{
	m_next.reset(const_cast<AlgorithmParametersBase &>(x).m_next.release());
	x.m_used = true;
}

/// \brief Construct a AlgorithmParametersBase
/// \param name the parameter name
/// \param throwIfNotUsed flags indicating whether an exception should be thrown
/// \details If throwIfNotUsed is true, then a ParameterNotUsed exception
///   will be thrown in the destructor if the parameter is not not retrieved.
AlgorithmParametersBase(const char *name, bool throwIfNotUsed)
	: m_name(name), m_throwIfNotUsed(throwIfNotUsed), m_used(false) {}

bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;

virtual void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const =0;
virtual void MoveInto(void *p) const =0;	// not really const

const char *m_name;
bool m_throwIfNotUsed;
mutable bool m_used;
member_ptr<AlgorithmParametersBase> m_next;

void AssignValue(const char *name, const std::type_info &valueType, void *pValue) const
{

void MoveInto(void *buffer) const
{
	AlgorithmParametersTemplate<T>* p = new(buffer) AlgorithmParametersTemplate<T>(*this);
	CRYPTOPP_UNUSED(p);	// silence warning
}

AlgorithmParameters(const AlgorithmParameters &x);

AlgorithmParameters & operator=(const AlgorithmParameters &x);

/// \tparam T the class or type
/// \param name the name of the object or value to retrieve
/// \param value reference to a variable that receives the value
/// \param throwIfNotUsed if true, the object will throw an exception if the value is not accessed
template <class T>
AlgorithmParameters & operator()(const char *name, const T &value, bool throwIfNotUsed)
{
	member_ptr<AlgorithmParametersBase> p(new AlgorithmParametersTemplate<T>(name, value, throwIfNotUsed));
	p->m_next.reset(m_next.release());
	m_next.reset(p.release());
	m_defaultThrowIfNotUsed = throwIfNotUsed;
	return *this;
}

/// \brief Appends a NameValuePair to a collection of NameValuePairs
/// \tparam T the class or type
/// \param name the name of the object or value to retrieve
/// \param value reference to a variable that receives the value
template <class T>
AlgorithmParameters & operator()(const char *name, const T &value)
{
	return operator()(name, value, m_defaultThrowIfNotUsed);
}

bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const;

/// \brief Construct an OID
OID() {}
/// \brief Construct an OID
/// \param v value to initialize the OID
OID(word32 v) : m_values(1, v) {}
/// \brief Construct an OID
/// \param bt BufferedTransformation object
OID(BufferedTransformation &bt) {BERDecode(bt);}

/// \brief Append a value to an OID
/// \param rhs the value to append
inline OID & operator+=(word32 rhs) {m_values.push_back(rhs); return *this;}

/// \brief DER encode this OID
/// \param bt BufferedTransformation object
void DEREncode(BufferedTransformation &bt) const;

/// \brief BER decode an OID
/// \param bt BufferedTransformation object
void BERDecode(BufferedTransformation &bt);

/// \brief BER decode an OID
/// \param bt BufferedTransformation object
/// \throws BERDecodeErr() if decoded value doesn't match an expected OID
/// \details BERDecodeAndCheck() can be used to parse an OID and verify it matches an expected.
/// <pre>
///   BERSequenceDecoder key(bt);
///   ...
///   BERSequenceDecoder algorithm(key);
///   GetAlgorithmID().BERDecodeAndCheck(algorithm);
/// </pre>
void BERDecodeAndCheck(BufferedTransformation &bt) const;

bool Empty() const {
	return m_values.empty();
}

const std::vector<word32>& GetValues() const {
	return m_values;
}

std::vector<word32> m_values;

virtual ~EncodedObjectFilter() {}

/// \brief Construct an EncodedObjectFilter
/// \param attachment a BufferedTrasformation to attach to this object
/// \param nObjects the number of objects
/// \param flags bitwise OR of EncodedObjectFilter::Flag
EncodedObjectFilter(BufferedTransformation *attachment = NULLPTR, unsigned int nObjects = 1, word32 flags = 0);

/// \brief Input a byte buffer for processing
/// \param inString the byte buffer to process
/// \param length the size of the string, in bytes
void Put(const byte *inString, size_t length);

unsigned int GetNumberOfCompletedObjects() const {return m_nCurrentObject;}
unsigned long GetPositionOfObject(unsigned int i) const {return m_positions[i];}

ByteQueue m_queue;
std::vector<unsigned int> m_positions;
lword m_lengthRemaining;
word32 m_nObjects, m_nCurrentObject, m_level, m_flags;
byte m_id;

explicit BERGeneralDecoder(BufferedTransformation &inQueue, byte asnTag);
explicit BERGeneralDecoder(BERGeneralDecoder &inQueue, byte asnTag);

bool IsDefiniteLength() const {return m_definiteLength;}
lword RemainingLength() const {CRYPTOPP_ASSERT(m_definiteLength); return m_length;}
bool EndReached() const;
byte PeekByte() const;
void CheckByte(byte b);

size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;

// call this to denote end of sequence
void MessageEnd();

explicit DERGeneralEncoder(BufferedTransformation &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED);
explicit DERGeneralEncoder(DERGeneralEncoder &outQueue, byte asnTag = SEQUENCE | CONSTRUCTED);

// call this to denote end of sequence
void MessageEnd();

/// \brief DER encode optional data
/// \param out BufferedTransformation object
void DEREncode(BufferedTransformation &out)
{
	if (this->get() != NULLPTR)
		this->get()->DEREncode(out);
}

/// \brief BER decode ASN.1 object
/// \param bt BufferedTransformation object
void Load(BufferedTransformation &bt)
	{BERDecode(bt);}

void BERDecode(BufferedTransformation &bt);
void DEREncode(BufferedTransformation &bt) const;

/// \brief Retrieves the OID of the algorithm
/// \returns OID of the algorithm
virtual OID GetAlgorithmID() const =0;
virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
	{BERDecodeNull(bt); return false;}
virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
	{DEREncodeNull(bt); return false;}	// see RFC 2459, section 7.3.1

/// decode subjectPublicKey part of subjectPublicKeyInfo, without the BIT STRING header
virtual void BERDecodePublicKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
/// encode subjectPublicKey part of subjectPublicKeyInfo, without the BIT STRING header
virtual void DEREncodePublicKey(BufferedTransformation &bt) const =0;

void BERDecode(BufferedTransformation &bt);
void DEREncode(BufferedTransformation &bt) const;

/// \brief Retrieves the OID of the algorithm
/// \returns OID of the algorithm
virtual OID GetAlgorithmID() const =0;
virtual bool BERDecodeAlgorithmParameters(BufferedTransformation &bt)
	{BERDecodeNull(bt); return false;}
virtual bool DEREncodeAlgorithmParameters(BufferedTransformation &bt) const
	{DEREncodeNull(bt); return false;}	// see RFC 2459, section 7.3.1

/// decode privateKey part of privateKeyInfo, without the OCTET STRING header
virtual void BERDecodePrivateKey(BufferedTransformation &bt, bool parametersPresent, size_t size) =0;
/// encode privateKey part of privateKeyInfo, without the OCTET STRING header
virtual void DEREncodePrivateKey(BufferedTransformation &bt) const =0;

/// decode optional attributes including context-specific tag
/*! /note default implementation stores attributes to be output in DEREncodeOptionalAttributes */
virtual void BERDecodeOptionalAttributes(BufferedTransformation &bt);
/// encode optional attributes including context-specific tag
virtual void DEREncodeOptionalAttributes(BufferedTransformation &bt) const;

size_t bc;
bool definite = BERLengthDecode(in, bc);
if (!definite)
	BERDecodeError();
if (bc > in.MaxRetrievable())  // Issue 346
	BERDecodeError();
if (asnTag == BOOLEAN && bc != 1) // X.690, 8.2.1
	BERDecodeError();
if ((asnTag == INTEGER || asnTag == ENUMERATED) && bc == 0) // X.690, 8.3.1 and 8.4
	BERDecodeError();

SecByteBlock buf(bc);

if (bc != in.Get(buf, bc))
	BERDecodeError();

// This consumes leading 0 octets. According to X.690, 8.3.2, it could be non-conforming behavior.
//  X.690, 8.3.2 says "the bits of the first octet and bit 8 of the second octet ... (a) shall
//  not all be ones and (b) shall not all be zeros ... These rules ensure that an integer value
//  is always encoded in the smallest possible number of octet".
// We invented AER (Alternate Encoding Rules), which is more relaxed than BER, CER, and DER.
const byte *ptr = buf;
while (bc > sizeof(w) && *ptr == 0)
{
	bc--;
	ptr++;
}
if (bc > sizeof(w))
	BERDecodeError();

w = 0;
for (unsigned int i=0; i<bc; i++)
	w = (w << 8) | ptr[i];

if (w < minValue || w > maxValue)
	BERDecodeError();

/// \brief Construct a BaseN_Encoder
/// \param alphabet table of ASCII characters to use as the alphabet
/// \param log2base the log<sub>2</sub>base
/// \param attachment a BufferedTransformation to attach to this object
/// \param padding the character to use as padding
/// \pre log2base must be between 1 and 7 inclusive
/// \throws InvalidArgument if log2base is not between 1 and 7
BaseN_Encoder(const byte *alphabet, int log2base, BufferedTransformation *attachment=NULLPTR, int padding=-1)
	: m_alphabet(NULLPTR), m_padding(0), m_bitsPerChar(0)
	, m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
{
	Detach(attachment);
	IsolatedInitialize(MakeParameters(Name::EncodingLookupArray(), alphabet)
		(Name::Log2Base(), log2base)
		(Name::Pad(), padding != -1)
		(Name::PaddingByte(), byte(padding)));
}

void IsolatedInitialize(const NameValuePairs &parameters);
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);

/// \brief Construct a BaseN_Decoder
/// \param lookup table of values
/// \param log2base the log<sub>2</sub>base
/// \param attachment a BufferedTransformation to attach to this object
/// \details log2base is the exponent (like 5 in 2<sup>5</sup>), and not
///   the number of elements (like 32).
/// \details padding is set to -1, which means use default padding. If not
///   required, then the value must be set via IsolatedInitialize().
BaseN_Decoder(const int *lookup, int log2base, BufferedTransformation *attachment=NULLPTR)
	: m_lookup(NULLPTR), m_bitsPerChar(0)
	, m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
{
	Detach(attachment);
	IsolatedInitialize(MakeParameters(Name::DecodingLookupArray(), lookup)(Name::Log2Base(), log2base));
}

void IsolatedInitialize(const NameValuePairs &parameters);
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);

/// \brief Initializes BaseN lookup array
/// \param lookup table of values
/// \param alphabet table of ASCII characters
/// \param base the base for the encoder
/// \param caseInsensitive flag indicating whether the alphabet is case sensitivie
/// \pre COUNTOF(lookup) == 256
/// \pre COUNTOF(alphabet) == base
/// \details Internally, the function sets the first 256 elements in the lookup table to
///  their value from the alphabet array or -1. base is the number of element (like 32),
///  and not an exponent (like 5 in 2<sup>5</sup>)
static void CRYPTOPP_API InitializeDecodingLookupArray(int *lookup, const byte *alphabet, unsigned int base, bool caseInsensitive);

/// \brief Construct a Grouper
/// \param groupSize the size of the grouping
/// \param separator the separator to use between groups
/// \param terminator the terminator appeand after processing
/// \param attachment a BufferedTransformation to attach to this object
Grouper(int groupSize, const std::string &separator, const std::string &terminator, BufferedTransformation *attachment=NULLPTR)
	: m_groupSize(0), m_counter(0)
{
	Detach(attachment);
	IsolatedInitialize(MakeParameters(Name::GroupSize(), groupSize)
		(Name::Separator(), ConstByteArrayParameter(separator))
		(Name::Terminator(), ConstByteArrayParameter(terminator)));
}

void IsolatedInitialize(const NameValuePairs &parameters);
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);

void Put(byte inByte);
void Put(const byte *inString, unsigned int length);

void Flush(bool completeFlush, int propagation=-1);
void MessageEnd(int propagation=-1);
void PutMessageEnd(const byte *inString, unsigned int length, int propagation=-1);
void MessageSeriesEnd(int propagation=-1);

typedef std::list<RangeRoute> RouteList;
typedef std::list<Route> DefaultRouteList;

RouteList m_routes;
DefaultRouteList m_defaultRoutes;
unsigned int m_nCurrentMessage;

typedef std::pair<BufferedTransformation *, value_ptr<std::string> > DefaultRoute;
typedef std::list<DefaultRoute> DefaultRouteList;

// SunCC workaround: can't use const_iterator here
typedef RouteMap::iterator MapIterator;
typedef DefaultRouteList::iterator ListIterator;

void Reset(const std::string &channel);
bool End() const;
void Next();
BufferedTransformation & Destination();
const std::string & Channel();

ChannelSwitch& m_cs;
std::string m_channel;
bool m_useDefault;
MapIterator m_itMapCurrent, m_itMapEnd;
ListIterator m_itListCurrent, m_itListEnd;

void IsolatedInitialize(const NameValuePairs &parameters=g_nullNameValuePairs);

size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking);
size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking);

bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true);
bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);

byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);

void AddDefaultRoute(BufferedTransformation &destination);
void RemoveDefaultRoute(BufferedTransformation &destination);
void AddDefaultRoute(BufferedTransformation &destination, const std::string &outChannel);
void RemoveDefaultRoute(BufferedTransformation &destination, const std::string &outChannel);
void AddRoute(const std::string &inChannel, BufferedTransformation &destination, const std::string &outChannel);
void RemoveRoute(const std::string &inChannel, BufferedTransformation &destination, const std::string &outChannel);

ChannelRouteIterator m_it;
bool m_blocked;

friend class ChannelRouteIterator;

// Security related, possible defects
// http://blogs.msdn.com/b/vcblog/archive/2010/12/14/off-by-default-compiler-warnings-in-visual-c.aspx

#if !defined(CRYPTOPP_DISABLE_SSE2) && (defined(_MSC_VER) || CRYPTOPP_GCC_VERSION >= 30300 || defined(__SSE2__))
	#define CRYPTOPP_SSE2_ASM_AVAILABLE 1
#endif

#if !defined(CRYPTOPP_DISABLE_SSSE3) && (_MSC_VER >= 1500 || CRYPTOPP_GCC_VERSION >= 40300 || defined(__SSSE3__))
	#define CRYPTOPP_SSSE3_ASM_AVAILABLE 1
#endif

(CRYPTOPP_GCC_VERSION >= 40300) || (__INTEL_COMPILER >= 1000) || (__SUNPRO_CC >= 0x5110) || \
(CRYPTOPP_LLVM_CLANG_VERSION >= 20300) || (CRYPTOPP_APPLE_CLANG_VERSION >= 40000)
#define CRYPTOPP_SSSE3_AVAILABLE 1

  (CRYPTOPP_MSC_VERSION >= 1700)

  (CRYPTOPP_GCC_VERSION >= 40800) || (CRYPTOPP_CLANG_VERSION >= 30300) || \
  (CRYPTOPP_MSC_VERSION >= 1916)

  (CRYPTOPP_CLANG_VERSION >= 30300) || (CRYPTOPP_MSC_VERSION >= 1916)

  (CRYPTOPP_CLANG_VERSION >= 30300) || (CRYPTOPP_MSC_VERSION >= 1916)

  (CRYPTOPP_CLANG_VERSION >= 30300) || (CRYPTOPP_MSC_VERSION >= 1910)

  (CRYPTOPP_CLANG_VERSION >= 30300) || (CRYPTOPP_MSC_VERSION >= 1916)

  (CRYPTOPP_MSC_VERSION >= 5000)

  (CRYPTOPP_MSC_VERSION >= 5000)

(CRYPTOPP_XLC_VERSION >= 100000) || (CRYPTOPP_GCC_VERSION >= 40001) || \
(CRYPTOPP_CLANG_VERSION >= 20900)

(CRYPTOPP_GCC_VERSION >= 40100) || (CRYPTOPP_CLANG_VERSION >= 30100)

(CRYPTOPP_GCC_VERSION >= 40800) || (CRYPTOPP_CLANG_VERSION >= 70000)

(CRYPTOPP_GCC_VERSION >= 70000) || (CRYPTOPP_CLANG_VERSION >= 80000)

(CRYPTOPP_GCC_VERSION >= 40800) || (CRYPTOPP_CLANG_VERSION >= 70000)

virtual ~Exception() throw() {}

/// \brief Construct a new Exception
explicit Exception(ErrorType errorType, const std::string &s) : m_errorType(errorType), m_what(s) {}

/// \brief Retrieves a C-string describing the exception
const char *what() const throw() {return (m_what.c_str());}
/// \brief Retrieves a string describing the exception
const std::string &GetWhat() const {return m_what;}
/// \brief Sets the error string for the exception
void SetWhat(const std::string &s) {m_what = s;}
/// \brief Retrieves the error type for the exception
ErrorType GetErrorType() const {return m_errorType;}
/// \brief Sets the error type for the exceptions
void SetErrorType(ErrorType errorType) {m_errorType = errorType;}

/// \brief Retrieve the operating system API that reported the error
const std::string & GetOperation() const {return m_operation;}
/// \brief Retrieve the error code returned by the operating system
int GetErrorCode() const {return m_errorCode;}

/// \brief Compare two DecodingResult
/// \param rhs the other DecodingResult
/// \return true if both isValidCoding and messageLength are equal, false otherwise
bool operator==(const DecodingResult &rhs) const {return isValidCoding == rhs.isValidCoding && messageLength == rhs.messageLength;}
/// \brief Compare two DecodingResult
/// \param rhs the other DecodingResult
/// \return true if either isValidCoding or messageLength is \a not equal, false otherwise
/// \details Returns <tt>!operator==(rhs)</tt>.
bool operator!=(const DecodingResult &rhs) const {return !operator==(rhs);}

/// \brief Flag to indicate the decoding is valid
bool isValidCoding;
/// \brief Recovered message length if isValidCoding is true, undefined otherwise
size_t messageLength;

/// \brief Thrown when an unexpected type is encountered
/// \details Exception thrown when trying to retrieve a value using a different type than expected
class CRYPTOPP_DLL ValueTypeMismatch : public InvalidArgument
{
public:
	/// \brief Construct a ValueTypeMismatch
	/// \param name the name of the value
	/// \param stored the \a actual type of the value stored
	/// \param retrieving the \a presumed type of the value retrieved
	ValueTypeMismatch(const std::string &name, const std::type_info &stored, const std::type_info &retrieving)
		: InvalidArgument("NameValuePairs: type mismatch for '" + name + "', stored '" + stored.name() + "', trying to retrieve '" + retrieving.name() + "'")
		, m_stored(stored), m_retrieving(retrieving) {}

	/// \brief Provides the stored type
	/// \return the C++ mangled name of the type
	const std::type_info & GetStoredTypeInfo() const {return m_stored;}

	/// \brief Provides the retrieveing type
	/// \return the C++ mangled name of the type
	const std::type_info & GetRetrievingTypeInfo() const {return m_retrieving;}

private:
	const std::type_info &m_stored;
	const std::type_info &m_retrieving;
};

/// \brief Get a copy of this object or subobject
/// \tparam T class or type
/// \param object reference to a variable that receives the value
template <class T>
bool GetThisObject(T &object) const
{
	return GetValue((std::string("ThisObject:")+typeid(T).name()).c_str(), object);
}

/// \brief Get a pointer to this object
/// \tparam T class or type
/// \param ptr reference to a pointer to a variable that receives the value
template <class T>
bool GetThisPointer(T *&ptr) const
{
	return GetValue((std::string("ThisPointer:")+typeid(T).name()).c_str(), ptr);
}

/// \brief Get a named value
/// \tparam T class or type
/// \param name the name of the object or value to retrieve
/// \param value reference to a variable that receives the value
/// \returns true if the value was retrieved, false otherwise
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
template <class T>
bool GetValue(const char *name, T &value) const
{
	return GetVoidValue(name, typeid(T), &value);
}

/// \brief Get a named value
/// \tparam T class or type
/// \param name the name of the object or value to retrieve
/// \param defaultValue the default value of the class or type if it does not exist
/// \return the object or value
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
template <class T>
T GetValueWithDefault(const char *name, T defaultValue) const
{
	T value;
	bool result = GetValue(name, value);
	// No assert... this recovers from failure
	if (result) {return value;}
	return defaultValue;
}

/// \brief Get a list of value names that can be retrieved
/// \return a list of names available to retrieve
/// \details the items in the list are delimited with a colon.
CRYPTOPP_DLL std::string GetValueNames() const
	{std::string result; GetValue("ValueNames", result); return result;}

/// \brief Get a named value with type int
/// \param name the name of the value to retrieve
/// \param value the value retrieved upon success
/// \return true if an int value was retrieved, false otherwise
/// \details GetIntValue() is used to ensure we don't accidentally try to get an
///   unsigned int or some other type when we mean int (which is the most common case)
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL bool GetIntValue(const char *name, int &value) const
	{return GetValue(name, value);}

/// \brief Get a named value with type int, with default
/// \param name the name of the value to retrieve
/// \param defaultValue the default value if the name does not exist
/// \return the value retrieved on success or the default value
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL int GetIntValueWithDefault(const char *name, int defaultValue) const
	{return GetValueWithDefault(name, defaultValue);}

/// \brief Get a named value with type word64
/// \param name the name of the value to retrieve
/// \param value the value retrieved upon success
/// \return true if an word64 value was retrieved, false otherwise
/// \sa GetValue(), GetValueWithDefault(), GetWord64ValueWithDefault(), GetIntValue(),
///   GetIntValueWithDefault(), GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL bool GetWord64Value(const char *name, word64 &value) const
	{return GetValue(name, value);}

/// \brief Get a named value with type word64, with default
/// \param name the name of the value to retrieve
/// \param defaultValue the default value if the name does not exist
/// \return the value retrieved on success or the default value
/// \sa GetValue(), GetValueWithDefault(), GetWord64Value(), GetIntValue(),
///   GetIntValueWithDefault(), GetRequiredParameter() and GetRequiredWord64Parameter()
CRYPTOPP_DLL word64 GetWord64ValueWithDefault(const char *name, word64 defaultValue) const
	{return GetValueWithDefault(name, defaultValue);}

/// \brief Ensures an expected name and type is present
/// \param name the name of the value
/// \param stored the type that was stored for the name
/// \param retrieving the type that is being retrieved for the name
/// \throws ValueTypeMismatch
/// \details ThrowIfTypeMismatch() effectively performs a type safety check.
///    stored and retrieving are C++ mangled names for the type.
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL static void CRYPTOPP_API ThrowIfTypeMismatch(const char *name, const std::type_info &stored, const std::type_info &retrieving)
	{if (stored != retrieving) throw ValueTypeMismatch(name, stored, retrieving);}

/// \brief Retrieves a required name/value pair
/// \tparam T class or type
/// \param className the name of the class
/// \param name the name of the value
/// \param value reference to a variable to receive the value
/// \throws InvalidArgument
/// \details GetRequiredParameter() throws InvalidArgument if the name
///   is not present or not of the expected type T.
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
template <class T>
void GetRequiredParameter(const char *className, const char *name, T &value) const
{
	if (!GetValue(name, value))
		throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
}

/// \brief Retrieves a required name/value pair
/// \param className the name of the class
/// \param name the name of the value
/// \param value reference to a variable to receive the value
/// \throws InvalidArgument
/// \details GetRequiredParameter() throws InvalidArgument if the name
///   is not present or not of the expected type T.
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL void GetRequiredIntParameter(const char *className, const char *name, int &value) const
{
	if (!GetIntValue(name, value))
		throw InvalidArgument(std::string(className) + ": missing required parameter '" + name + "'");
}

/// \brief Get a named value
/// \param name the name of the object or value to retrieve
/// \param valueType reference to a variable that receives the value
/// \param pValue void pointer to a variable that receives the value
/// \returns true if the value was retrieved, false otherwise
/// \details GetVoidValue() retrieves the value of name if it exists.
/// \note GetVoidValue() is an internal function and should be implemented
///   by derived classes. Users should use one of the other functions instead.
/// \sa GetValue(), GetValueWithDefault(), GetIntValue(), GetIntValueWithDefault(),
///   GetRequiredParameter() and GetRequiredIntParameter()
CRYPTOPP_DLL virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0;

/// \brief Copies  this object
/// \return a copy of this object
/// \throws NotImplemented
/// \note this is \a not implemented by most classes
/// \sa NotCopyable
virtual Clonable* Clone() const {throw NotImplemented("Clone() is not implemented yet.");}	// TODO: make this =0

/// \brief Interface for all crypto algorithms
/// \param checkSelfTestStatus determines whether the object can proceed if the self
///   tests have not been run or failed.
/// \details When FIPS 140-2 compliance is enabled and checkSelfTestStatus == true,
///   this constructor throws SelfTestFailure if the self test hasn't been run or fails.
/// \details FIPS 140-2 compliance is disabled by default. It is only used by certain
///   versions of the library when the library is built as a DLL on Windows. Also see
///    CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2 in config.h.
Algorithm(bool checkSelfTestStatus = true);

/// \brief Provides the name of this algorithm
/// \return the standard algorithm name
/// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
///   Some algorithms do not have standard names yet. For example, there is no standard
///   algorithm name for Shoup's ECIES.
/// \note AlgorithmName is not universally implemented yet.
virtual std::string AlgorithmName() const {return "unknown";}

/// \brief Retrieve the provider of this algorithm
/// \return the algorithm provider
/// \details The algorithm provider can be a name like "C++", "SSE", "NEON", "AESNI",
///    "ARMv8" and "Power8". C++ is standard C++ code. Other labels, like SSE,
///    usually indicate a specialized implementation using instructions from a higher
///    instruction set architecture (ISA). Future labels may include external hardware
///    like a hardware security module (HSM).
/// \details Generally speaking Wei Dai's original IA-32 ASM code falls under "SSE2".
///    Labels like "SSSE3" and "SSE4.1" follow after Wei's code and use intrinsics
///    instead of ASM.
/// \details Algorithms which combine different instructions or ISAs provide the
///    dominant one. For example on x86 <tt>AES/GCM</tt> returns "AESNI" rather than
///    "CLMUL" or "AES+SSE4.1" or "AES+CLMUL" or "AES+SSE4.1+CLMUL".
/// \note Provider is not universally implemented yet.
/// \since Crypto++ 8.0
virtual std::string AlgorithmProvider() const {return "C++";}

/// \brief Returns smallest valid key length
/// \returns the minimum key length, in bytes
virtual size_t MinKeyLength() const =0;

/// \brief Returns largest valid key length
/// \returns the maximum key length, in bytes
virtual size_t MaxKeyLength() const =0;

/// \brief Returns default key length
/// \returns the default key length, in bytes
virtual size_t DefaultKeyLength() const =0;

/// \brief Returns a valid key length for the algorithm
/// \param keylength the size of the key, in bytes
/// \returns the valid key length, in bytes
/// \details keylength is provided in bytes, not bits. If keylength is less than MIN_KEYLENGTH,
///   then the function returns MIN_KEYLENGTH. If keylength is greater than MAX_KEYLENGTH,
///   then the function returns MAX_KEYLENGTH. if If keylength is a multiple of KEYLENGTH_MULTIPLE,
///   then keylength is returned. Otherwise, the function returns a \a lower multiple of
///   KEYLENGTH_MULTIPLE.
virtual size_t GetValidKeyLength(size_t keylength) const =0;

/// \brief Returns whether keylength is a valid key length
/// \param keylength the requested keylength
/// \return true if keylength is valid, false otherwise
/// \details Internally the function calls GetValidKeyLength()
virtual bool IsValidKeyLength(size_t keylength) const
	{return keylength == GetValidKeyLength(keylength);}

/// \brief Sets or reset the key of this object
/// \param key the key to use when keying the object
/// \param length the size of the key, in bytes
/// \param params additional initialization parameters to configure this object
virtual void SetKey(const byte *key, size_t length, const NameValuePairs &params = g_nullNameValuePairs);

/// \brief Sets or reset the key of this object
/// \param key the key to use when keying the object
/// \param length the size of the key, in bytes
/// \param rounds the number of rounds to apply the transformation function,
///   if applicable
/// \details SetKeyWithRounds() calls SetKey() with a NameValuePairs
///   object that only specifies rounds. rounds is an integer parameter,
///   and <tt>-1</tt> means use the default number of rounds.
void SetKeyWithRounds(const byte *key, size_t length, int rounds);

/// \brief Sets or reset the key of this object
/// \param key the key to use when keying the object
/// \param length the size of the key, in bytes
/// \param iv the initialization vector to use when keying the object
/// \param ivLength the size of the iv, in bytes
/// \details SetKeyWithIV() calls SetKey() with a NameValuePairs
///   that only specifies IV. The IV is a byte buffer with size ivLength.
///   ivLength is an integer parameter, and <tt>-1</tt> means use IVSize().
void SetKeyWithIV(const byte *key, size_t length, const byte *iv, size_t ivLength);

/// \brief Sets or reset the key of this object
/// \param key the key to use when keying the object
/// \param length the size of the key, in bytes
/// \param iv the initialization vector to use when keying the object
/// \details SetKeyWithIV() calls SetKey() with a NameValuePairs() object
///   that only specifies iv. iv is a byte buffer, and it must have
///   a size IVSize().
void SetKeyWithIV(const byte *key, size_t length, const byte *iv)
	{SetKeyWithIV(key, length, iv, IVSize());}

/// \brief Secure IVs requirements as enumerated values.
/// \details Provides secure IV requirements as a monotonically increasing enumerated values.
///   Requirements can be compared using less than (&lt;) and greater than (&gt;). For example,
///   <tt>UNIQUE_IV &lt; RANDOM_IV</tt> and <tt>UNPREDICTABLE_RANDOM_IV &gt; RANDOM_IV</tt>.
/// \details Objects that use SimpleKeyingInterface do not support an optional IV. That is,
///	  an IV must be present or it must be absent. If you wish to support an optional IV then
///   provide two classes - one with an IV and one without an IV.
/// \sa IsResynchronizable(), CanUseRandomIVs(), CanUsePredictableIVs(), CanUseStructuredIVs()
enum IV_Requirement {
	/// \brief The IV must be unique
	UNIQUE_IV = 0,
	/// \brief The IV must be random and possibly predictable
	RANDOM_IV,
	/// \brief The IV must be random and unpredictable
	UNPREDICTABLE_RANDOM_IV,
	/// \brief The IV is set by the object
	INTERNALLY_GENERATED_IV,
	/// \brief The object does not use an IV
	NOT_RESYNCHRONIZABLE
};

/// \brief Minimal requirement for secure IVs
/// \return the secure IV requirement of the algorithm
virtual IV_Requirement IVRequirement() const =0;

/// \brief Determines if the object can be resynchronized
/// \return true if the object can be resynchronized (i.e. supports initialization vectors), false otherwise
/// \note If this function returns true, and no IV is passed to SetKey() and <tt>CanUseStructuredIVs()==true</tt>,
///   an IV of all 0's will be assumed.
bool IsResynchronizable() const {return IVRequirement() < NOT_RESYNCHRONIZABLE;}

/// \brief Determines if the object can use random IVs
/// \return true if the object can use random IVs (in addition to ones returned by GetNextIV), false otherwise
bool CanUseRandomIVs() const {return IVRequirement() <= UNPREDICTABLE_RANDOM_IV;}

/// \brief Determines if the object can use random but possibly predictable IVs
/// \return true if the object can use random but possibly predictable IVs (in addition to ones returned by
///    GetNextIV), false otherwise
bool CanUsePredictableIVs() const {return IVRequirement() <= RANDOM_IV;}

/// \brief Determines if the object can use structured IVs
/// \returns true if the object can use structured IVs, false otherwise
/// \details CanUseStructuredIVs() indicates whether the object can use structured IVs; for example a counter
///    (in addition to ones returned by GetNextIV).
bool CanUseStructuredIVs() const {return IVRequirement() <= UNIQUE_IV;}

/// \brief Returns length of the IV accepted by this object
/// \return the size of an IV, in bytes
/// \throws NotImplemented() if the object does not support resynchronization
/// \details The default implementation throws NotImplemented
virtual unsigned int IVSize() const
	{throw NotImplemented(GetAlgorithm().AlgorithmName() + ": this object doesn't support resynchronization");}

/// \brief Provides the default size of an IV
/// \return default length of IVs accepted by this object, in bytes
unsigned int DefaultIVLength() const {return IVSize();}

/// \brief Provides the minimum size of an IV
/// \return minimal length of IVs accepted by this object, in bytes
/// \throws NotImplemented() if the object does not support resynchronization
virtual unsigned int MinIVLength() const {return IVSize();}

/// \brief Provides the maximum size of an IV
/// \return maximal length of IVs accepted by this object, in bytes
/// \throws NotImplemented() if the object does not support resynchronization
virtual unsigned int MaxIVLength() const {return IVSize();}

/// \brief Resynchronize with an IV
/// \param iv the initialization vector
/// \param ivLength the size of the initialization vector, in bytes
/// \details Resynchronize() resynchronizes with an IV provided by the caller. <tt>ivLength=-1</tt> means use IVSize().
/// \throws NotImplemented() if the object does not support resynchronization
virtual void Resynchronize(const byte *iv, int ivLength=-1) {
	CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(ivLength);
	throw NotImplemented(GetAlgorithm().AlgorithmName() + ": this object doesn't support resynchronization");
}

/// \brief Retrieves a secure IV for the next message
/// \param rng a RandomNumberGenerator to produce keying material
/// \param iv a block of bytes to receive the IV
/// \details The IV must be at least IVSize() in length.
/// \details This method should be called after you finish encrypting one message and are ready
///    to start the next one. After calling it, you must call SetKey() or Resynchronize().
///    before using this object again.
/// \details Internally, the base class implementation calls RandomNumberGenerator's GenerateBlock()
/// \note This method is not implemented on decryption objects.
virtual void GetNextIV(RandomNumberGenerator &rng, byte *iv);

/// \brief Sets the key for this object without performing parameter validation
/// \param key a byte buffer used to key the cipher
/// \param length the length of the byte buffer
/// \param params additional parameters passed as NameValuePairs
/// \details key must be at least DEFAULT_KEYLENGTH in length.
virtual void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params) =0;

/// \brief Validates the key length
/// \param length the size of the keying material, in bytes
/// \throws InvalidKeyLength if the key length is invalid
void ThrowIfInvalidKeyLength(size_t length);

/// \brief Validates the object
/// \throws InvalidArgument if the IV is present
/// \details Internally, the default implementation calls IsResynchronizable() and throws
///    InvalidArgument if the function returns  true.
/// \note called when no IV is passed
void ThrowIfResynchronizable();

/// \brief Validates the IV
/// \param iv the IV with a length of IVSize, in bytes
/// \throws InvalidArgument on failure
/// \details Internally, the default implementation checks the iv. If iv is not NULL or nullptr,
///   then the function succeeds. If iv is NULL, then IVRequirement is checked against
///    UNPREDICTABLE_RANDOM_IV. If IVRequirement is UNPREDICTABLE_RANDOM_IV, then
///   then the function succeeds. Otherwise, an exception is thrown.
void ThrowIfInvalidIV(const byte *iv);

/// \brief Validates the IV length
/// \param length the size of an IV, in bytes
/// \throws InvalidArgument if the IV length is invalid
size_t ThrowIfInvalidIVLength(int length);

/// \brief Retrieves and validates the IV
/// \param params NameValuePairs with the IV supplied as a ConstByteArrayParameter
/// \param size the length of the IV, in bytes
/// \return a pointer to the first byte of the IV
/// \throws InvalidArgument if the number of rounds are invalid
const byte * GetIVAndThrowIfInvalid(const NameValuePairs &params, size_t &size);

/// \brief Validates the key length
/// \param length the size of the keying material, in bytes
inline void AssertValidKeyLength(size_t length) const
	{CRYPTOPP_UNUSED(length); CRYPTOPP_ASSERT(IsValidKeyLength(length));}

/// \brief Encrypt or decrypt a block
/// \param inBlock the input message before processing
/// \param outBlock the output message after processing
/// \param xorBlock an optional XOR mask
/// \details ProcessAndXorBlock encrypts or decrypts inBlock, xor with xorBlock, and write to outBlock.
/// \details The size of the block is determined by the block cipher and its documentation. Use
///     BLOCKSIZE at compile time, or BlockSize() at runtime.
/// \note The message can be transformed in-place, or the buffers must \a not overlap
/// \sa FixedBlockSize, BlockCipherFinal from seckey.h and BlockSize()
virtual void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const =0;

/// \brief Encrypt or decrypt a block
/// \param inBlock the input message before processing
/// \param outBlock the output message after processing
/// \details ProcessBlock encrypts or decrypts inBlock and write to outBlock.
/// \details The size of the block is determined by the block cipher and its documentation.
///    Use BLOCKSIZE at compile time, or BlockSize() at runtime.
/// \sa FixedBlockSize, BlockCipherFinal from seckey.h and BlockSize()
/// \note The message can be transformed in-place, or the buffers must \a not overlap
void ProcessBlock(const byte *inBlock, byte *outBlock) const
	{ProcessAndXorBlock(inBlock, NULLPTR, outBlock);}

/// \brief Encrypt or decrypt a block in place
/// \param inoutBlock the input message before processing
/// \details ProcessBlock encrypts or decrypts inoutBlock in-place.
/// \details The size of the block is determined by the block cipher and its documentation.
///    Use BLOCKSIZE at compile time, or BlockSize() at runtime.
/// \sa FixedBlockSize, BlockCipherFinal from seckey.h and BlockSize()
void ProcessBlock(byte *inoutBlock) const
	{ProcessAndXorBlock(inoutBlock, NULLPTR, inoutBlock);}

/// Provides the block size of the cipher
/// \return the block size of the cipher, in bytes
virtual unsigned int BlockSize() const =0;

/// \brief Provides input and output data alignment for optimal performance.
/// \return the input data alignment that provides optimal performance
/// \sa GetAlignment() and OptimalBlockSize()
virtual unsigned int OptimalDataAlignment() const;

/// \brief Determines if the transformation is a permutation
/// \returns true if this is a permutation (i.e. there is an inverse transformation)
virtual bool IsPermutation() const {return true;}

/// \brief Determines if the cipher is being operated in its forward direction
/// \returns true if DIR is ENCRYPTION, false otherwise
/// \sa IsForwardTransformation(), IsPermutation(), GetCipherDirection()
virtual bool IsForwardTransformation() const =0;

/// \brief Determines the number of blocks that can be processed in parallel
/// \return the number of blocks that can be processed in parallel, for bit-slicing implementations
/// \details Bit-slicing is often used to improve throughput and minimize timing attacks.
virtual unsigned int OptimalNumberOfParallelBlocks() const {return 1;}

/// \brief Bit flags that control AdvancedProcessBlocks() behavior
enum FlagsForAdvancedProcessBlocks {
	/// \brief inBlock is a counter
	BT_InBlockIsCounter=1,
	/// \brief should not modify block pointers
	BT_DontIncrementInOutPointers=2,
	/// \brief Xor inputs before transformation
	BT_XorInput=4,
	/// \brief perform the transformation in reverse
	BT_ReverseDirection=8,
	/// \brief Allow parallel transformations
	BT_AllowParallel=16};

/// \brief Encrypt and xor multiple blocks using additional flags
/// \param inBlocks the input message before processing
/// \param xorBlocks an optional XOR mask
/// \param outBlocks the output message after processing
/// \param length the size of the blocks, in bytes
/// \param flags additional flags to control processing
/// \details Encrypt and xor multiple blocks according to FlagsForAdvancedProcessBlocks flags.
/// \note If BT_InBlockIsCounter is set, then the last byte of inBlocks may be modified.
virtual size_t AdvancedProcessBlocks(const byte *inBlocks, const byte *xorBlocks, byte *outBlocks, size_t length, word32 flags) const;

/// \brief Provides the direction of the cipher
/// \return ENCRYPTION if IsForwardTransformation() is true, DECRYPTION otherwise
/// \sa IsForwardTransformation(), IsPermutation()
inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}

/// \brief Provides a reference to this object
/// \return A reference to this object
/// \details Useful for passing a temporary object to a function that takes a non-const reference
StreamTransformation& Ref() {return *this;}

/// \brief Provides the mandatory block size of the cipher
/// \return The block size of the cipher if input must be processed in blocks, 1 otherwise
/// \details Stream ciphers and some block ciphers modes of operation return 1. Modes that
///   return 1 must be able to process a single byte at a time, like counter mode. If a
///   mode of operation or block cipher cannot stream then it must not return 1.
/// \details When filters operate the mode or cipher, ProcessData will be called with a
///   string of bytes that is determined by MandatoryBlockSize and OptimalBlockSize. When a
///   policy is set, like 16-byte strings for a 16-byte block cipher, the filter will buffer
///   bytes until the specified number of bytes is available to the object.
/// \sa ProcessData, ProcessLastBlock, MandatoryBlockSize, MinLastBlockSize, BlockPaddingSchemeDef, IsLastBlockSpecial
virtual unsigned int MandatoryBlockSize() const {return 1;}

/// \brief Provides the input block size most efficient for this cipher
/// \return The input block size that is most efficient for the cipher
/// \details The base class implementation returns MandatoryBlockSize().
/// \note Optimal input length is
///   <tt>n * OptimalBlockSize() - GetOptimalBlockSizeUsed()</tt> for any <tt>n \> 0</tt>.
virtual unsigned int OptimalBlockSize() const {return MandatoryBlockSize();}

/// \brief Provides the number of bytes used in the current block when processing at optimal block size.
/// \return the number of bytes used in the current block when processing at the optimal block size
virtual unsigned int GetOptimalBlockSizeUsed() const {return 0;}

/// \brief Provides input and output data alignment for optimal performance
/// \return the input data alignment that provides optimal performance
/// \sa GetAlignment() and OptimalBlockSize()
virtual unsigned int OptimalDataAlignment() const;

/// \brief Encrypt or decrypt an array of bytes
/// \param outString the output byte buffer
/// \param inString the input byte buffer
/// \param length the size of the input and output byte buffers, in bytes
/// \details ProcessData is called with a string of bytes whose size depends on MandatoryBlockSize.
///   Either <tt>inString == outString</tt>, or they must not overlap.
/// \sa ProcessData, ProcessLastBlock, MandatoryBlockSize, MinLastBlockSize, BlockPaddingSchemeDef, IsLastBlockSpecial
virtual void ProcessData(byte *outString, const byte *inString, size_t length) =0;

/// \brief Encrypt or decrypt the last block of data
/// \param outString the output byte buffer
/// \param outLength the size of the output byte buffer, in bytes
/// \param inString the input byte buffer
/// \param inLength the size of the input byte buffer, in bytes
/// \returns the number of bytes used in outString
/// \details ProcessLastBlock is used when the last block of data is special and requires handling
///   by the cipher. The current implementation provides an output buffer with a size
///   <tt>inLength+2*MandatoryBlockSize()</tt>. The return value allows the cipher to expand cipher
///   text during encryption or shrink plain text during decryption.
/// \details This member function is used by CBC-CTS and OCB modes.
/// \sa ProcessData, ProcessLastBlock, MandatoryBlockSize, MinLastBlockSize, BlockPaddingSchemeDef, IsLastBlockSpecial
virtual size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength);

/// \brief Provides the size of the last block
/// \returns the minimum size of the last block
/// \details MinLastBlockSize() returns the minimum size of the last block. 0 indicates the last
///   block is not special.
/// \details MandatoryBlockSize() enlists one of two behaviors. First, if MandatoryBlockSize()
///   returns 1, then the cipher can be streamed and ProcessData() is called with the tail bytes.
///   Second, if MandatoryBlockSize() returns non-0, then the string of bytes is padded to
///   MandatoryBlockSize() according to the padding mode. Then, ProcessData() is called with the
///   padded string of bytes.
/// \details Some authenticated encryption modes are not expressed well with MandatoryBlockSize()
///   and MinLastBlockSize(). For example, AES/OCB uses 16-byte blocks (MandatoryBlockSize = 16)
///   and the last block requires special processing (MinLastBlockSize = 0). However, 0 is a valid
///   last block size for OCB and the special processing is custom padding, and not standard PKCS
///   padding. In response an unambiguous IsLastBlockSpecial() was added.
/// \sa ProcessData, ProcessLastBlock, MandatoryBlockSize, MinLastBlockSize, BlockPaddingSchemeDef, IsLastBlockSpecial
virtual unsigned int MinLastBlockSize() const {return 0;}

/// \brief Determines if the last block receives special processing
/// \returns true if the last block reveives special processing, false otherwise.
/// \details Some authenticated encryption modes are not expressed well with
///   MandatoryBlockSize() and MinLastBlockSize(). For example, AES/OCB uses
///   16-byte blocks (MandatoryBlockSize = 16) and the last block requires special processing
///   (MinLastBlockSize = 0). However, 0 is a valid last block size for OCB and the special
///   processing is custom padding, and not standard PKCS padding. In response an
///   unambiguous IsLastBlockSpecial() was added.
///  \details When IsLastBlockSpecial() returns false nothing special happens. All the former
///   rules and behaviors apply. This is the default behavior of IsLastBlockSpecial().
///  \details When IsLastBlockSpecial() returns true four things happen. First, MinLastBlockSize = 0
///   means 0 is a valid block size that should be processed. Second, standard block cipher padding is
///   \a not \a applied. Third, the caller supplies an outString is larger than inString by
///   <tt>2*MandatoryBlockSize()</tt>. That is, there's a reserve available when processing the last block.
///   Fourth, the cipher is responsible for finalization like custom padding. The cipher will tell
///   the library how many bytes were processed or used by returning the appropriate value from
///   ProcessLastBlock().
/// \details The return value of ProcessLastBlock() indicates how many bytes were written to
///   <tt>outString</tt>. A filter pipelining data will send <tt>outString</tt> and up to <tt>outLength</tt>
///   to an <tt>AttachedTransformation()</tt> for additional processing. Below is an example of the code
///   used in <tt>StreamTransformationFilter::LastPut</tt>.
/// <pre>  if (m_cipher.IsLastBlockSpecial())
///   {
///     size_t reserve = 2*m_cipher.MandatoryBlockSize();
///     space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, length+reserve);
///     length = m_cipher.ProcessLastBlock(space, length+reserve, inString, length);
///     AttachedTransformation()->Put(space, length);
///     return;
///   }</pre>
/// \sa ProcessData, ProcessLastBlock, MandatoryBlockSize, MinLastBlockSize, BlockPaddingSchemeDef, IsLastBlockSpecial
/// \since Crypto++ 6.0
virtual bool IsLastBlockSpecial() const {return false;}

/// \brief Encrypt or decrypt a string of bytes
/// \param inoutString the string to process
/// \param length the size of the inoutString, in bytes
/// \details Internally, the base class implementation calls ProcessData().
inline void ProcessString(byte *inoutString, size_t length)
	{ProcessData(inoutString, inoutString, length);}

/// \brief Encrypt or decrypt a string of bytes
/// \param outString the output string to process
/// \param inString the input string to process
/// \param length the size of the input and output strings, in bytes
/// \details Internally, the base class implementation calls ProcessData().
inline void ProcessString(byte *outString, const byte *inString, size_t length)
	{ProcessData(outString, inString, length);}

/// \brief Encrypt or decrypt a byte
/// \param input the input byte to process
/// \details Internally, the base class implementation calls ProcessData() with a size of 1.
inline byte ProcessByte(byte input)
	{ProcessData(&input, &input, 1); return input;}

/// \brief Determines whether the cipher supports random access
/// \returns true if the cipher supports random access, false otherwise
virtual bool IsRandomAccess() const =0;

/// \brief Seek to an absolute position
/// \param pos position to seek
/// \throws NotImplemented
/// \details The base class implementation throws NotImplemented. The function
///   \ref CRYPTOPP_ASSERT "asserts" IsRandomAccess() in debug builds.
virtual void Seek(lword pos)
{
	CRYPTOPP_UNUSED(pos);
	CRYPTOPP_ASSERT(!IsRandomAccess());
	throw NotImplemented("StreamTransformation: this object doesn't support random access");
}

/// \brief Determines whether the cipher is self-inverting
/// \returns true if the cipher is self-inverting, false otherwise
/// \details IsSelfInverting determines whether this transformation is
///   self-inverting (e.g. xor with a keystream).
virtual bool IsSelfInverting() const =0;

/// \brief Determines if the cipher is being operated in its forward direction
/// \returns true if DIR is ENCRYPTION, false otherwise
/// \sa IsForwardTransformation(), IsPermutation(), GetCipherDirection()
virtual bool IsForwardTransformation() const =0;

/// \brief Provides a reference to this object
/// \return A reference to this object
/// \details Useful for passing a temporary object to a function that takes a non-const reference
HashTransformation& Ref() {return *this;}

/// \brief Updates a hash with additional input
/// \param input the additional input as a buffer
/// \param length the size of the buffer, in bytes
virtual void Update(const byte *input, size_t length) =0;

/// \brief Request space which can be written into by the caller
/// \param size the requested size of the buffer
/// \details The purpose of this method is to help avoid extra memory allocations.
/// \details size is an \a IN and \a OUT parameter and used as a hint. When the call is made,
///   size is the requested size of the buffer. When the call returns, size is the size of
///   the array returned to the caller.
/// \details The base class implementation sets size to 0 and returns NULL or nullptr.
/// \note Some objects, like ArraySink, cannot create a space because its fixed.
virtual byte * CreateUpdateSpace(size_t &size) {size=0; return NULLPTR;}

/// \brief Computes the hash of the current message
/// \param digest a pointer to the buffer to receive the hash
/// \details Final() restarts the hash for a new message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual void Final(byte *digest)
	{TruncatedFinal(digest, DigestSize());}

/// \brief Restart the hash
/// \details Discards the current state, and restart for a new message
virtual void Restart()
	{TruncatedFinal(NULLPTR, 0);}

/// Provides the digest size of the hash
/// \return the digest size of the hash.
virtual unsigned int DigestSize() const =0;

/// Provides the tag size of the hash
/// \return the tag size of the hash.
/// \details Same as DigestSize().
unsigned int TagSize() const {return DigestSize();}

/// \brief Provides the block size of the compression function
/// \return block size of the compression function, in bytes
/// \details BlockSize() will return 0 if the hash is not block based
///   or does not have an equivalent block size. For example, Keccak
///   and SHA-3 do not have a block size, but they do have an equivalent
///   block size called rate expressed as <tt>r</tt>.
virtual unsigned int BlockSize() const {return 0;}

/// \brief Provides the input block size most efficient for this hash.
/// \return The input block size that is most efficient for the cipher
/// \details The base class implementation returns MandatoryBlockSize().
/// \details Optimal input length is
///   <tt>n * OptimalBlockSize() - GetOptimalBlockSizeUsed()</tt> for any <tt>n \> 0</tt>.
virtual unsigned int OptimalBlockSize() const {return 1;}

/// \brief Provides input and output data alignment for optimal performance
/// \return the input data alignment that provides optimal performance
/// \sa GetAlignment() and OptimalBlockSize()
virtual unsigned int OptimalDataAlignment() const;

/// \brief Updates the hash with additional input and computes the hash of the current message
/// \param digest a pointer to the buffer to receive the hash
/// \param input the additional input as a buffer
/// \param length the size of the buffer, in bytes
/// \details Use this if your input is in one piece and you don't want to call Update()
///   and Final() separately
/// \details CalculateDigest() restarts the hash for the next message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual void CalculateDigest(byte *digest, const byte *input, size_t length)
	{Update(input, length); Final(digest);}

/// \brief Verifies the hash of the current message
/// \param digest a pointer to the buffer of an \a existing hash
/// \return \p true if the existing hash matches the computed hash, \p false otherwise
/// \throws ThrowIfInvalidTruncatedSize() if the existing hash's size exceeds DigestSize()
/// \details Verify() performs a bitwise compare on the buffers using VerifyBufsEqual(), which is
///   a constant time comparison function. digestLength cannot exceed DigestSize().
/// \details Verify() restarts the hash for the next message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual bool Verify(const byte *digest)
	{return TruncatedVerify(digest, DigestSize());}

/// \brief Updates the hash with additional input and verifies the hash of the current message
/// \param digest a pointer to the buffer of an \a existing hash
/// \param input the additional input as a buffer
/// \param length the size of the buffer, in bytes
/// \return \p true if the existing hash matches the computed hash, \p false otherwise
/// \throws ThrowIfInvalidTruncatedSize() if the existing hash's size exceeds DigestSize()
/// \details Use this if your input is in one piece and you don't want to call Update()
///   and Verify() separately
/// \details VerifyDigest() performs a bitwise compare on the buffers using VerifyBufsEqual(),
///   which is a constant time comparison function. digestLength cannot exceed DigestSize().
/// \details VerifyDigest() restarts the hash for the next message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual bool VerifyDigest(const byte *digest, const byte *input, size_t length)
	{Update(input, length); return Verify(digest);}

/// \brief Computes the hash of the current message
/// \param digest a pointer to the buffer to receive the hash
/// \param digestSize the size of the truncated digest, in bytes
/// \details TruncatedFinal() call Final() and then copies digestSize bytes to digest.
///   The hash is restarted the hash for the next message.
virtual void TruncatedFinal(byte *digest, size_t digestSize) =0;

/// \brief Updates the hash with additional input and computes the hash of the current message
/// \param digest a pointer to the buffer to receive the hash
/// \param digestSize the length of the truncated hash, in bytes
/// \param input the additional input as a buffer
/// \param length the size of the buffer, in bytes
/// \details Use this if your input is in one piece and you don't want to call Update()
///   and CalculateDigest() separately.
/// \details CalculateTruncatedDigest() restarts the hash for the next message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual void CalculateTruncatedDigest(byte *digest, size_t digestSize, const byte *input, size_t length)
	{Update(input, length); TruncatedFinal(digest, digestSize);}

/// \brief Verifies the hash of the current message
/// \param digest a pointer to the buffer of an \a existing hash
/// \param digestLength the size of the truncated hash, in bytes
/// \return \p true if the existing hash matches the computed hash, \p false otherwise
/// \throws ThrowIfInvalidTruncatedSize() if digestLength exceeds DigestSize()
/// \details TruncatedVerify() is a truncated version of Verify(). It can operate on a
///   buffer smaller than DigestSize(). However, digestLength cannot exceed DigestSize().
/// \details Verify() performs a bitwise compare on the buffers using VerifyBufsEqual(), which is
///   a constant time comparison function. digestLength cannot exceed DigestSize().
/// \details TruncatedVerify() restarts the hash for the next message.
virtual bool TruncatedVerify(const byte *digest, size_t digestLength);

/// \brief Updates the hash with additional input and verifies the hash of the current message
/// \param digest a pointer to the buffer of an \a existing hash
/// \param digestLength the size of the truncated hash, in bytes
/// \param input the additional input as a buffer
/// \param length the size of the buffer, in bytes
/// \return \p true if the existing hash matches the computed hash, \p false otherwise
/// \throws ThrowIfInvalidTruncatedSize() if digestLength exceeds DigestSize()
/// \details Use this if your input is in one piece and you don't want to call Update()
///   and TruncatedVerify() separately.
/// \details VerifyTruncatedDigest() is a truncated version of VerifyDigest(). It can operate
///   on a buffer smaller than DigestSize(). However, digestLength cannot exceed DigestSize().
/// \details VerifyTruncatedDigest() restarts the hash for the next message.
/// \pre <tt>COUNTOF(digest) == DigestSize()</tt> or <tt>COUNTOF(digest) == HASH::DIGESTSIZE</tt> ensures
///   the output byte buffer is large enough for the digest.
virtual bool VerifyTruncatedDigest(const byte *digest, size_t digestLength, const byte *input, size_t length)
	{Update(input, length); return TruncatedVerify(digest, digestLength);}

/// \brief Exception thrown when the object is in the wrong state for the operation
/// \details this indicates that a member function was called in the wrong state, for example trying to encrypt
///   a message before having set the key or IV
class BadState : public Exception
{
public:
	explicit BadState(const std::string &name, const char *message) : Exception(OTHER_ERROR, name + ": " + message) {}
	explicit BadState(const std::string &name, const char *function, const char *state) : Exception(OTHER_ERROR, name + ": " + function + " was called before " + state) {}
};

/// \brief Provides the maximum length of AAD that can be input
/// \return the maximum length of AAD that can be input before the encrypted data
virtual lword MaxHeaderLength() const =0;

/// \brief Provides the maximum length of encrypted data
/// \return the maximum length of encrypted data
virtual lword MaxMessageLength() const =0;

/// \brief Provides the the maximum length of AAD
/// \return the maximum length of AAD that can be input after the encrypted data
virtual lword MaxFooterLength() const {return 0;}

/// \brief Determines if data lengths must be specified prior to inputting data
/// \return true if the data lengths are required before inputting data, false otherwise
/// \details if this function returns true, SpecifyDataLengths() must be called before attempting to input data.
///   This is the case for some schemes, such as CCM.
/// \sa SpecifyDataLengths()
virtual bool NeedsPrespecifiedDataLengths() const {return false;}

/// \brief Prescribes the data lengths
/// \param headerLength size of data before message is input, in bytes
/// \param messageLength size of the message, in bytes
/// \param footerLength size of data after message is input, in bytes
/// \details SpecifyDataLengths() only needs to be called if NeedsPrespecifiedDataLengths() returns <tt>true</tt>.
///   If <tt>true</tt>, then <tt>headerLength</tt> will be validated against <tt>MaxHeaderLength()</tt>,
///   <tt>messageLength</tt> will be validated against <tt>MaxMessageLength()</tt>, and
///   <tt>footerLength</tt> will be validated against <tt>MaxFooterLength()</tt>.
/// \sa NeedsPrespecifiedDataLengths()
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0);

/// \brief Encrypts and calculates a MAC in one call
/// \param ciphertext the encryption buffer
/// \param mac the mac buffer
/// \param macSize the size of the MAC buffer, in bytes
/// \param iv the iv buffer
/// \param ivLength the size of the IV buffer, in bytes
/// \param header the AAD buffer
/// \param headerLength the size of the AAD buffer, in bytes
/// \param message the message buffer
/// \param messageLength the size of the messagetext buffer, in bytes
/// \details EncryptAndAuthenticate() encrypts and generates the MAC in one call. The function
///   truncates the MAC if <tt>macSize < TagSize()</tt>.
virtual void EncryptAndAuthenticate(byte *ciphertext, byte *mac, size_t macSize, const byte *iv, int ivLength, const byte *header, size_t headerLength, const byte *message, size_t messageLength);

/// \brief Decrypts and verifies a MAC in one call
/// \param message the decryption buffer
/// \param mac the mac buffer
/// \param macSize the size of the MAC buffer, in bytes
/// \param iv the iv buffer
/// \param ivLength the size of the IV buffer, in bytes
/// \param header the AAD buffer
/// \param headerLength the size of the AAD buffer, in bytes
/// \param ciphertext the ciphertext buffer
/// \param ciphertextLength the size of the ciphertext buffer, in bytes
/// \return true if the MAC is valid and the decoding succeeded, false otherwise
/// \details DecryptAndVerify() decrypts and verifies the MAC in one call.
/// <tt>message</tt> is a decryption buffer and should be at least as large as the ciphertext buffer.
/// \details The function returns true iff MAC is valid. DecryptAndVerify() assumes the MAC
///  is truncated if <tt>macLength < TagSize()</tt>.
virtual bool DecryptAndVerify(byte *message, const byte *mac, size_t macSize, const byte *iv, int ivLength, const byte *header, size_t headerLength, const byte *ciphertext, size_t ciphertextLength);

/// \brief Provides the name of this algorithm
/// \return the standard algorithm name
/// \details The standard algorithm name can be a name like \a AES or \a AES/GCM. Some algorithms
///   do not have standard names yet. For example, there is no standard algorithm name for
///   Shoup's ECIES.
virtual std::string AlgorithmName() const;

/// \brief Update RNG state with additional unpredictable values
/// \param input the entropy to add to the generator
/// \param length the size of the input buffer
/// \throws NotImplemented
/// \details A generator may or may not accept additional entropy. Call CanIncorporateEntropy()
///   to test for the ability to use additional entropy.
/// \details If a derived class does not override IncorporateEntropy(), then the base class
///   throws NotImplemented.
virtual void IncorporateEntropy(const byte *input, size_t length)
{
	CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(length);
	throw NotImplemented("RandomNumberGenerator: IncorporateEntropy not implemented");
}

/// \brief Determines if a generator can accept additional entropy
/// \return true if IncorporateEntropy() is implemented
virtual bool CanIncorporateEntropy() const {return false;}

/// \brief Generate new random byte and return it
/// \return a random 8-bit byte
/// \details Default implementation calls GenerateBlock() with one byte.
/// \details All generated values are uniformly distributed over the range specified within the
///   the constraints of a particular generator.
virtual byte GenerateByte();

/// \brief Generate new random bit and return it
/// \return a random bit
/// \details The default implementation calls GenerateByte() and return its lowest bit.
/// \details All generated values are uniformly distributed over the range specified within the
///   the constraints of a particular generator.
virtual unsigned int GenerateBit();

/// \brief Generate a random 32 bit word in the range min to max, inclusive
/// \param min the lower bound of the range
/// \param max the upper bound of the range
/// \return a random 32-bit word
/// \details The default implementation calls Crop() on the difference between max and
///    min, and then returns the result added to min.
/// \details All generated values are uniformly distributed over the range specified within the
///   the constraints of a particular generator.
virtual word32 GenerateWord32(word32 min=0, word32 max=0xffffffffUL);

/// \brief Generate random array of bytes
/// \param output the byte buffer
/// \param size the length of the buffer, in bytes
/// \details All generated values are uniformly distributed over the range specified within the
///   the constraints of a particular generator.
/// \note A derived generator \a must override either GenerateBlock() or
///   GenerateIntoBufferedTransformation(). They can override both, or have one call the other.
virtual void GenerateBlock(byte *output, size_t size);

/// \brief Generate random bytes into a BufferedTransformation
/// \param target the BufferedTransformation object which receives the bytes
/// \param channel the channel on which the bytes should be pumped
/// \param length the number of bytes to generate
/// \details The default implementation calls GenerateBlock() and pumps the result into
///   the DEFAULT_CHANNEL of the target.
/// \details All generated values are uniformly distributed over the range specified within the
///   the constraints of a particular generator.
/// \note A derived generator \a must override either GenerateBlock() or
///    GenerateIntoBufferedTransformation(). They can override both, or have one call the other.
virtual void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length);

/// \brief Generate and discard n bytes
/// \param n the number of bytes to generate and discard
virtual void DiscardBytes(size_t n);

/// \brief Randomly shuffle the specified array
/// \param begin an iterator to the first element in the array
/// \param end an iterator beyond the last element in the array
/// \details The resulting permutation is uniformly distributed.
template <class IT> void Shuffle(IT begin, IT end)
{
	// TODO: What happens if there are more than 2^32 elements?
	for (; begin != end; ++begin)
		std::iter_swap(begin, begin + GenerateWord32(0, static_cast<word32>(end-begin-1)));
}

/// \brief Provides the name of this algorithm
/// \return the standard algorithm name
virtual std::string AlgorithmName() const =0;

/// \brief Determine minimum number of bytes
/// \returns Minimum number of bytes which can be derived
virtual size_t MinDerivedLength() const;

/// \brief Determine maximum number of bytes
/// \returns Maximum number of bytes which can be derived
virtual size_t MaxDerivedLength() const;

/// \brief Returns a valid key length for the derivation function
/// \param keylength the size of the derived key, in bytes
/// \returns the valid key length, in bytes
virtual size_t GetValidDerivedLength(size_t keylength) const =0;

/// \brief Returns whether keylength is a valid key length
/// \param keylength the requested keylength
/// \return true if the derived keylength is valid, false otherwise
/// \details Internally the function calls GetValidKeyLength()
virtual bool IsValidDerivedLength(size_t keylength) const {
	return keylength == GetValidDerivedLength(keylength);
}

/// \brief Derive a key from a seed
/// \param derived the derived output buffer
/// \param derivedLen the size of the derived buffer, in bytes
/// \param secret the seed input buffer
/// \param secretLen the size of the secret buffer, in bytes
/// \param params additional initialization parameters to configure this object
/// \returns the number of iterations performed
/// \throws InvalidDerivedLength if <tt>derivedLen</tt> is invalid for the scheme
/// \details DeriveKey() provides a standard interface to derive a key from
///   a secret seed and other parameters. Each class that derives from KeyDerivationFunction
///   provides an overload that accepts most parameters used by the derivation function.
/// \details the number of iterations performed by DeriveKey() may be 1. For example, a
///   scheme like HKDF does not use the iteration count so it returns 1.
virtual size_t DeriveKey(byte *derived, size_t derivedLen, const byte *secret, size_t secretLen, const NameValuePairs& params = g_nullNameValuePairs) const =0;

/// \brief Set or change parameters
/// \param params additional initialization parameters to configure this object
/// \details SetParameters() is useful for setting common parameters when an object is
///   reused. Some derivation function classes may choose to implement it.
virtual void SetParameters(const NameValuePairs& params);

/// \brief Validates the derived key length
/// \param length the size of the derived key material, in bytes
/// \throws InvalidKeyLength if the key length is invalid
void ThrowIfInvalidDerivedLength(size_t length) const;

/// \brief Maximum number of wait objects that this object can return
/// \return the maximum number of wait objects
virtual unsigned int GetMaxWaitObjectCount() const =0;

/// \brief Retrieves waitable objects
/// \param container the wait container to receive the references to the objects.
/// \param callStack CallStack() object used to select waitable objects
/// \details GetWaitObjects() is usually called in one of two ways. First, it can
///   be called like <tt>something.GetWaitObjects(c, CallStack("my func after X", 0));</tt>.
///   Second, if in an outer GetWaitObjects() method that itself takes a callStack
///   parameter, it can be called like
///   <tt>innerThing.GetWaitObjects(c, CallStack("MyClass::GetWaitObjects at X", &callStack));</tt>.
virtual void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack) =0;

/// \brief Wait on this object
/// \return true if the wait succeeded, false otherwise
/// \details Wait() is the same as creating an empty container, calling GetWaitObjects(), and then calling
///   Wait() on the container.
bool Wait(unsigned long milliseconds, CallStack const& callStack);

/// \brief Construct a BufferedTransformation
BufferedTransformation() : Algorithm(false) {}

/// \brief Provides a reference to this object
/// \return A reference to this object
/// \details Useful for passing a temporary object to a function that takes a non-const reference
BufferedTransformation& Ref() {return *this;}

///	\name INPUT
//@{

	/// \brief Input a byte for processing
	/// \param inByte the 8-bit byte (octet) to be processed.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	/// \details <tt>Put(byte)</tt> calls <tt>Put(byte*, size_t)</tt>.
	size_t Put(byte inByte, bool blocking=true)
		{return Put(&inByte, 1, blocking);}

	/// \brief Input a byte buffer for processing
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	/// \details Internally, Put() calls Put2().
	size_t Put(const byte *inString, size_t length, bool blocking=true)
		{return Put2(inString, length, 0, blocking);}

	/// Input a 16-bit word for processing.
	/// \param value the 16-bit value to be processed
	/// \param order the ByteOrder of the value to be processed.
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	size_t PutWord16(word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);

	/// Input a 32-bit word for processing.
	/// \param value the 32-bit value to be processed.
	/// \param order the ByteOrder of the value to be processed.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	size_t PutWord32(word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);

	/// \brief Request space which can be written into by the caller
	/// \param size the requested size of the buffer
	/// \return byte pointer to the space to input data
	/// \details The purpose of this method is to help avoid extra memory allocations.
	/// \details size is an \a IN and \a OUT parameter and used as a hint. When the call is made,
	///   size is the requested size of the buffer. When the call returns, size is the size of
	///   the array returned to the caller.
	/// \details The base class implementation sets size to 0 and returns NULL.
	/// \note Some objects, like ArraySink, cannot create a space because its fixed. In the case of
	/// an ArraySink, the pointer to the array is returned and the size is remaining size.
	virtual byte * CreatePutSpace(size_t &size)
		{size=0; return NULLPTR;}

	/// \brief Determines whether input can be modified by the callee
	/// \return true if input can be modified, false otherwise
	/// \details The base class implementation returns false.
	virtual bool CanModifyInput() const
		{return false;}

	/// \brief Input multiple bytes that may be modified by callee.
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	size_t PutModifiable(byte *inString, size_t length, bool blocking=true)
		{return PutModifiable2(inString, length, 0, blocking);}

	/// \brief Signals the end of messages to the object
	/// \param propagation the number of attached transformations the MessageEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	bool MessageEnd(int propagation=-1, bool blocking=true)
		{return !!Put2(NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}

	/// \brief Input multiple bytes for processing and signal the end of a message
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param propagation the number of attached transformations the MessageEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	/// \details Internally, PutMessageEnd() calls Put2() with a modified propagation to
	///    ensure all attached transformations finish processing the message.
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	size_t PutMessageEnd(const byte *inString, size_t length, int propagation=-1, bool blocking=true)
		{return Put2(inString, length, propagation < 0 ? -1 : propagation+1, blocking);}

	/// \brief Input multiple bytes for processing
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param messageEnd means how many filters to signal MessageEnd() to, including this one
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	/// \details Derived classes must implement Put2().
	virtual size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking) =0;

	/// \brief Input multiple bytes that may be modified by callee.
	/// \param inString the byte buffer to process.
	/// \param length the size of the string, in bytes.
	/// \param messageEnd means how many filters to signal MessageEnd() to, including this one.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return the number of bytes that remain in the block (i.e., bytes not processed). 0 indicates all
	///   bytes were processed.
	/// \details Internally, PutModifiable2() calls Put2().
	virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
		{return Put2(inString, length, messageEnd, blocking);}

	/// \brief Exception thrown by objects that have \a not implemented nonblocking input processing
	/// \details BlockingInputOnly inherits from NotImplemented
	struct BlockingInputOnly : public NotImplemented
		{BlockingInputOnly(const std::string &s) : NotImplemented(s + ": Nonblocking input is not implemented by this object.") {}};
//@}

///	\name WAITING
//@{
	/// \brief Retrieves the maximum number of waitable objects
	unsigned int GetMaxWaitObjectCount() const;

	/// \brief Retrieves waitable objects
	/// \param container the wait container to receive the references to the objects
	/// \param callStack CallStack() object used to select waitable objects
	/// \details GetWaitObjects is usually called in one of two ways. First, it can
	///    be called like <tt>something.GetWaitObjects(c, CallStack("my func after X", 0));</tt>.
	///    Second, if in an outer GetWaitObjects() method that itself takes a callStack
	///    parameter, it can be called like
	///    <tt>innerThing.GetWaitObjects(c, CallStack("MyClass::GetWaitObjects at X", &callStack));</tt>.
	void GetWaitObjects(WaitObjectContainer &container, CallStack const& callStack);
//@} // WAITING

///	\name SIGNALS
//@{

	/// \brief Initialize or reinitialize this object, without signal propagation
	/// \param parameters a set of NameValuePairs to initialize this object
	/// \throws NotImplemented
	/// \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
	///   number of arbitrarily typed arguments. The function avoids the need for multiple constructors providing
	///   all possible combintations of configurable parameters.
	/// \details IsolatedInitialize() does not call Initialize() on attached transformations. If initialization
	///   should be propagated, then use the Initialize() function.
	/// \details If a derived class does not override IsolatedInitialize(), then the base class throws
	///   NotImplemented.
	virtual void IsolatedInitialize(const NameValuePairs &parameters) {
		CRYPTOPP_UNUSED(parameters);
		throw NotImplemented("BufferedTransformation: this object can't be reinitialized");
	}

	/// \brief Flushes data buffered by this object, without signal propagation
	/// \param hardFlush indicates whether all data should be flushed
	/// \param blocking specifies whether the object should block when processing input
	/// \note hardFlush must be used with care
	virtual bool IsolatedFlush(bool hardFlush, bool blocking) =0;

	/// \brief Marks the end of a series of messages, without signal propagation
	/// \param blocking specifies whether the object should block when completing the processing on
	///    the current series of messages
	virtual bool IsolatedMessageSeriesEnd(bool blocking)
		{CRYPTOPP_UNUSED(blocking); return false;}

	/// \brief Initialize or reinitialize this object, with signal propagation
	/// \param parameters a set of NameValuePairs to initialize or reinitialize this object
	/// \param propagation the number of attached transformations the Initialize() signal should be passed
	/// \details Initialize() is used to initialize or reinitialize an object using a variable number of
	///   arbitrarily typed arguments. The function avoids the need for multiple constructors providing
	///   all possible combintations of configurable parameters.
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	virtual void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1);

	/// \brief Flush buffered input and/or output, with signal propagation
	/// \param hardFlush is used to indicate whether all data should be flushed
	/// \param propagation the number of attached transformations the Flush() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	/// \note Hard flushes must be used with care. It means try to process and output everything, even if
	///   there may not be enough data to complete the action. For example, hard flushing a HexDecoder
	///   would cause an error if you do it after inputing an odd number of hex encoded characters.
	/// \note For some types of filters, like  ZlibDecompressor, hard flushes can only
	///   be done at "synchronization points". These synchronization points are positions in the data
	///   stream that are created by hard flushes on the corresponding reverse filters, in this
	///   example ZlibCompressor. This is useful when zlib compressed data is moved across a
	///   network in packets and compression state is preserved across packets, as in the SSH2 protocol.
	virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);

	/// \brief Marks the end of a series of messages, with signal propagation
	/// \param propagation the number of attached transformations the MessageSeriesEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \details Each object that receives the signal will perform its processing, decrement
	///    propagation, and then pass the signal on to attached transformations if the value is not 0.
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	/// \note There should be a MessageEnd() immediately before MessageSeriesEnd().
	virtual bool MessageSeriesEnd(int propagation=-1, bool blocking=true);

	/// \brief Set propagation of automatically generated and transferred signals
	/// \param propagation then new value
	/// \details Setting propagation to <tt>0</tt> means do not automatically generate signals. Setting
	///    propagation to <tt>-1</tt> means unlimited propagation.
	virtual void SetAutoSignalPropagation(int propagation)
		{CRYPTOPP_UNUSED(propagation);}

	/// \brief Retrieve automatic signal propagation value
	/// \return the number of attached transformations the signal is propagated to. 0 indicates
	///   the signal is only witnessed by this object
	virtual int GetAutoSignalPropagation() const {return 0;}

///	\name RETRIEVAL OF ONE MESSAGE
//@{

	/// \brief Provides the number of bytes ready for retrieval
	/// \return the number of bytes ready for retrieval
	/// \details All retrieval functions return the actual number of bytes retrieved, which is
	///   the lesser of the request number and  MaxRetrievable()
	virtual lword MaxRetrievable() const;

	/// \brief Determines whether bytes are ready for retrieval
	/// \returns true if bytes are available for retrieval, false otherwise
	virtual bool AnyRetrievable() const;

	/// \brief Retrieve a 8-bit byte
	/// \param outByte the 8-bit value to be retrieved
	/// \return the number of bytes consumed during the call.
	/// \details Use the return value of Get to detect short reads.
	virtual size_t Get(byte &outByte);

	/// \brief Retrieve a block of bytes
	/// \param outString a block of bytes
	/// \param getMax the number of bytes to Get
	/// \return the number of bytes consumed during the call.
	/// \details Use the return value of Get to detect short reads.
	virtual size_t Get(byte *outString, size_t getMax);

	/// \brief Peek a 8-bit byte
	/// \param outByte the 8-bit value to be retrieved
	/// \return the number of bytes read during the call.
	/// \details Peek does not remove bytes from the object. Use the return value of
	///     Get() to detect short reads.
	virtual size_t Peek(byte &outByte) const;

	/// \brief Peek a block of bytes
	/// \param outString a block of bytes
	/// \param peekMax the number of bytes to Peek
	/// \return the number of bytes read during the call.
	/// \details Peek does not remove bytes from the object. Use the return value of
	///     Get() to detect short reads.
	virtual size_t Peek(byte *outString, size_t peekMax) const;

	/// \brief Retrieve a 16-bit word
	/// \param value the 16-bit value to be retrieved
	/// \param order the ByteOrder of the value to be processed.
	/// \return the number of bytes consumed during the call.
	/// \details Use the return value of GetWord16() to detect short reads.
	size_t GetWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER);

	/// \brief Retrieve a 32-bit word
	/// \param value the 32-bit value to be retrieved
	/// \param order the ByteOrder of the value to be processed.
	/// \return the number of bytes consumed during the call.
	/// \details Use the return value of GetWord16() to detect short reads.
	size_t GetWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER);

	/// \brief Peek a 16-bit word
	/// \param value the 16-bit value to be retrieved
	/// \param order the ByteOrder of the value to be processed.
	/// \return the number of bytes consumed during the call.
	/// \details Peek does not consume bytes in the stream. Use the return value
	///    of GetWord16() to detect short reads.
	size_t PeekWord16(word16 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;

	/// \brief Peek a 32-bit word
	/// \param value the 32-bit value to be retrieved
	/// \param order the ByteOrder of the value to be processed.
	/// \return the number of bytes consumed during the call.
	/// \details Peek does not consume bytes in the stream. Use the return value
	///    of GetWord16() to detect short reads.
	size_t PeekWord32(word32 &value, ByteOrder order=BIG_ENDIAN_ORDER) const;

	/// move transferMax bytes of the buffered output to target as input

	/// \brief Transfer bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param transferMax the number of bytes to transfer
	/// \param channel the channel on which the transfer should occur
	/// \return the number of bytes transferred during the call.
	/// \details TransferTo removes bytes from this object and moves them to the destination.
	/// \details The function always returns transferMax. If an accurate count is needed, then use TransferTo2().
	lword TransferTo(BufferedTransformation &target, lword transferMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL)
		{TransferTo2(target, transferMax, channel); return transferMax;}

	/// \brief Discard skipMax bytes from the output buffer
	/// \param skipMax the number of bytes to discard
	/// \details Skip() discards bytes from the output buffer, which is the AttachedTransformation(), if present.
	///   The function always returns the parameter <tt>skipMax</tt>.
	/// \details If you want to skip bytes from a Source, then perform the following.
	/// <pre>
	///     StringSource ss(str, false, new Redirector(TheBitBucket()));
	///     ss.Pump(10);    // Skip 10 bytes from Source
	///     ss.Detach(new FilterChain(...));
	///     ss.PumpAll();
	/// </pre>
	virtual lword Skip(lword skipMax=LWORD_MAX);

	/// copy copyMax bytes of the buffered output to target as input

	/// \brief Copy bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param copyMax the number of bytes to copy
	/// \param channel the channel on which the transfer should occur
	/// \return the number of bytes copied during the call.
	/// \details CopyTo copies bytes from this object to the destination. The bytes are not removed from this object.
	/// \details The function always returns copyMax. If an accurate count is needed, then use CopyRangeTo2().
	lword CopyTo(BufferedTransformation &target, lword copyMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL) const
		{return CopyRangeTo(target, 0, copyMax, channel);}

	/// \brief Copy bytes from this object using an index to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param position the 0-based index of the byte stream to begin the copying
	/// \param copyMax the number of bytes to copy
	/// \param channel the channel on which the transfer should occur
	/// \return the number of bytes copied during the call.
	/// \details CopyTo copies bytes from this object to the destination. The bytes remain in this
	///   object. Copying begins at the index position in the current stream, and not from an absolute
	///   position in the stream.
	/// \details The function returns the new position in the stream after transferring the bytes starting at the index.
	lword CopyRangeTo(BufferedTransformation &target, lword position, lword copyMax=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL) const
		{lword i = position; CopyRangeTo2(target, i, i+copyMax, channel); return i-position;}
//@}

///	\name RETRIEVAL OF MULTIPLE MESSAGES
//@{

	/// \brief Provides the number of bytes ready for retrieval
	/// \return the number of bytes ready for retrieval
	virtual lword TotalBytesRetrievable() const;

	/// \brief Provides the number of meesages processed by this object
	/// \return the number of meesages processed by this object
	/// \details NumberOfMessages returns number of times MessageEnd() has been
	///    received minus messages retrieved or skipped
	virtual unsigned int NumberOfMessages() const;

	/// \brief Determines if any messages are available for retrieval
	/// \returns true if <tt>NumberOfMessages() &gt; 0</tt>, false otherwise
	/// \details AnyMessages returns true if <tt>NumberOfMessages() &gt; 0</tt>
	virtual bool AnyMessages() const;

	/// \brief Start retrieving the next message
	/// \return true if a message is ready for retrieval
	/// \details GetNextMessage() returns true if a message is ready for retrieval; false
	///   if no more messages exist or this message is not completely retrieved.
	virtual bool GetNextMessage();

	/// \brief Skip a number of meessages
	/// \return 0 if the requested number of messages was skipped, non-0 otherwise
	/// \details SkipMessages() skips count number of messages. If there is an AttachedTransformation()
	///   then SkipMessages() is called on the attached transformation. If there is no attached
	///   transformation, then count number of messages are sent to TheBitBucket() using TransferMessagesTo().
	virtual unsigned int SkipMessages(unsigned int count=UINT_MAX);

	/// \brief Transfer messages from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param count the number of messages to transfer
	/// \param channel the channel on which the transfer should occur
	/// \return the number of bytes that remain in the current transfer block (i.e., bytes not transferred)
	/// \details TransferMessagesTo2() removes messages from this object and moves them to the destination.
	///   If all bytes are not transferred for a message, then processing stops and the number of remaining
	///   bytes is returned. TransferMessagesTo() does not proceed to the next message.
	/// \details A return value of 0 indicates all messages were successfully transferred.
	unsigned int TransferMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL)
		{TransferMessagesTo2(target, count, channel); return count;}

	/// \brief Copy messages from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param count the number of messages to transfer
	/// \param channel the channel on which the transfer should occur
	/// \return the number of bytes that remain in the current transfer block (i.e., bytes not transferred)
	/// \details CopyMessagesTo copies messages from this object and copies them to the destination.
	///   If all bytes are not transferred for a message, then processing stops and the number of remaining
	///   bytes is returned. CopyMessagesTo() does not proceed to the next message.
	/// \details A return value of 0 indicates all messages were successfully copied.
	unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL) const;

	/// \brief Skip all messages in the series
	virtual void SkipAll();

	/// \brief Transfer all bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param channel the channel on which the transfer should occur
	/// \details TransferMessagesTo2() removes messages from this object and moves them to the destination.
	///   Internally TransferAllTo() calls TransferAllTo2().
	void TransferAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL)
		{TransferAllTo2(target, channel);}

	/// \brief Copy messages from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param channel the channel on which the transfer should occur
	/// \details CopyAllTo copies messages from this object and copies them to the destination.
	void CopyAllTo(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL) const;

	/// \brief Retrieve the next message in a series
	/// \return true if a message was retreved, false otherwise
	/// \details Internally, the base class implementation returns false.
	virtual bool GetNextMessageSeries() {return false;}
	/// \brief Provides the number of messages in a series
	/// \return the number of messages in this series
	virtual unsigned int NumberOfMessagesInThisSeries() const {return NumberOfMessages();}
	/// \brief Provides the number of messages in a series
	/// \return the number of messages in this series
	virtual unsigned int NumberOfMessageSeries() const {return 0;}
//@}

///	\name NON-BLOCKING TRANSFER OF OUTPUT
//@{

	// upon return, byteCount contains number of bytes that have finished being transferred,
	// and returns the number of bytes left in the current transfer block

	/// \brief Transfer bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param byteCount the number of bytes to transfer
	/// \param channel the channel on which the transfer should occur
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the transfer block (i.e., bytes not transferred)
	/// \details TransferTo() removes bytes from this object and moves them to the destination.
	///   Transfer begins at the index position in the current stream, and not from an absolute
	///   position in the stream.
	/// \details byteCount is an \a IN and \a OUT parameter. When the call is made,
	///   byteCount is the requested size of the transfer. When the call returns, byteCount is
	///   the number of bytes that were transferred.
	virtual size_t TransferTo2(BufferedTransformation &target, lword &byteCount, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) =0;

	// upon return, begin contains the start position of data yet to be finished copying,
	// and returns the number of bytes left in the current transfer block

	/// \brief Copy bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param begin the 0-based index of the first byte to copy in the stream
	/// \param end the 0-based index of the last byte to copy in the stream
	/// \param channel the channel on which the transfer should occur
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the copy block (i.e., bytes not copied)
	/// \details CopyRangeTo2 copies bytes from this object to the destination. The bytes are not
	///   removed from this object. Copying begins at the index position in the current stream, and
	///   not from an absolute position in the stream.
	/// \details begin is an \a IN and \a OUT parameter. When the call is made, begin is the
	///   starting position of the copy. When the call returns, begin is the position of the first
	///   byte that was \a not copied (which may be different than end). begin can be used for
	///   subsequent calls to CopyRangeTo2().
	virtual size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const =0;

	// upon return, messageCount contains number of messages that have finished being transferred,
	// and returns the number of bytes left in the current transfer block

	/// \brief Transfer messages from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param messageCount the number of messages to transfer
	/// \param channel the channel on which the transfer should occur
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the current transfer block (i.e., bytes not transferred)
	/// \details TransferMessagesTo2() removes messages from this object and moves them to the destination.
	/// \details messageCount is an \a IN and \a OUT parameter. When the call is made, messageCount is the
	///   the number of messages requested to be transferred. When the call returns, messageCount is the
	///   number of messages actually transferred.
	size_t TransferMessagesTo2(BufferedTransformation &target, unsigned int &messageCount, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);

	// returns the number of bytes left in the current transfer block

	/// \brief Transfer all bytes from this object to another BufferedTransformation
	/// \param target the destination BufferedTransformation
	/// \param channel the channel on which the transfer should occur
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the current transfer block (i.e., bytes not transferred)
	/// \details TransferMessagesTo2() removes messages from this object and moves them to the destination.
	size_t TransferAllTo2(BufferedTransformation &target, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
//@}

///	\name CHANNELS
//@{
	/// \brief Exception thrown when a filter does not support named channels
	struct NoChannelSupport : public NotImplemented
		{NoChannelSupport(const std::string &name) : NotImplemented(name + ": this object doesn't support multiple channels") {}};
	/// \brief Exception thrown when a filter does not recognize a named channel
	struct InvalidChannelName : public InvalidArgument
		{InvalidChannelName(const std::string &name, const std::string &channel) : InvalidArgument(name + ": unexpected channel name \"" + channel + "\"") {}};

	/// \brief Input a byte for processing on a channel
	/// \param channel the channel to process the data.
	/// \param inByte the 8-bit byte (octet) to be processed.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	size_t ChannelPut(const std::string &channel, byte inByte, bool blocking=true)
		{return ChannelPut(channel, &inByte, 1, blocking);}

	/// \brief Input a byte buffer for processing on a channel
	/// \param channel the channel to process the data
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param blocking specifies whether the object should block when processing input
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	size_t ChannelPut(const std::string &channel, const byte *inString, size_t length, bool blocking=true)
		{return ChannelPut2(channel, inString, length, 0, blocking);}

	/// \brief Input multiple bytes that may be modified by callee on a channel
	/// \param channel the channel to process the data.
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param blocking specifies whether the object should block when processing input
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	size_t ChannelPutModifiable(const std::string &channel, byte *inString, size_t length, bool blocking=true)
		{return ChannelPutModifiable2(channel, inString, length, 0, blocking);}

	/// \brief Input a 16-bit word for processing on a channel.
	/// \param channel the channel to process the data.
	/// \param value the 16-bit value to be processed.
	/// \param order the ByteOrder of the value to be processed.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	size_t ChannelPutWord16(const std::string &channel, word16 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);

	/// \brief Input a 32-bit word for processing on a channel.
	/// \param channel the channel to process the data.
	/// \param value the 32-bit value to be processed.
	/// \param order the ByteOrder of the value to be processed.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	size_t ChannelPutWord32(const std::string &channel, word32 value, ByteOrder order=BIG_ENDIAN_ORDER, bool blocking=true);

	/// \brief Signal the end of a message
	/// \param channel the channel to process the data.
	/// \param propagation the number of attached transformations the ChannelMessageEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \return 0 indicates all bytes were processed during the call. Non-0 indicates the
	///   number of bytes that were not processed.
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	bool ChannelMessageEnd(const std::string &channel, int propagation=-1, bool blocking=true)
		{return !!ChannelPut2(channel, NULLPTR, 0, propagation < 0 ? -1 : propagation+1, blocking);}

	/// \brief Input multiple bytes for processing and signal the end of a message
	/// \param channel the channel to process the data.
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param propagation the number of attached transformations the ChannelPutMessageEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed)
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	size_t ChannelPutMessageEnd(const std::string &channel, const byte *inString, size_t length, int propagation=-1, bool blocking=true)
		{return ChannelPut2(channel, inString, length, propagation < 0 ? -1 : propagation+1, blocking);}

	/// \brief Request space which can be written into by the caller
	/// \param channel the channel to process the data
	/// \param size the requested size of the buffer
	/// \return a pointer to a memory block with length size
	/// \details The purpose of this method is to help avoid extra memory allocations.
	/// \details size is an \a IN and \a OUT parameter and used as a hint. When the call is made,
	///   size is the requested size of the buffer. When the call returns, size is the size of
	///   the array returned to the caller.
	/// \details The base class implementation sets size to 0 and returns NULL.
	/// \note Some objects, like ArraySink(), cannot create a space because its fixed. In the case of
	/// an ArraySink(), the pointer to the array is returned and the size is remaining size.
	virtual byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);

	/// \brief Input multiple bytes for processing on a channel.
	/// \param channel the channel to process the data.
	/// \param inString the byte buffer to process.
	/// \param length the size of the string, in bytes.
	/// \param messageEnd means how many filters to signal MessageEnd() to, including this one.
	/// \param blocking specifies whether the object should block when processing input.
	/// \return the number of bytes that remain in the block (i.e., bytes not processed)
	virtual size_t ChannelPut2(const std::string &channel, const byte *inString, size_t length, int messageEnd, bool blocking);

	/// \brief Input multiple bytes that may be modified by callee on a channel
	/// \param channel the channel to process the data
	/// \param inString the byte buffer to process
	/// \param length the size of the string, in bytes
	/// \param messageEnd means how many filters to signal MessageEnd() to, including this one
	/// \param blocking specifies whether the object should block when processing input
	/// \return the number of bytes that remain in the block (i.e., bytes not processed)
	virtual size_t ChannelPutModifiable2(const std::string &channel, byte *inString, size_t length, int messageEnd, bool blocking);

	/// \brief Flush buffered input and/or output on a channel
	/// \param channel the channel to flush the data
	/// \param hardFlush is used to indicate whether all data should be flushed
	/// \param propagation the number of attached transformations the ChannelFlush() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \return true of the Flush was successful
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true);

	/// \brief Marks the end of a series of messages on a channel
	/// \param channel the channel to signal the end of a series of messages
	/// \param propagation the number of attached transformations the ChannelMessageSeriesEnd() signal should be passed
	/// \param blocking specifies whether the object should block when processing input
	/// \details Each object that receives the signal will perform its processing, decrement
	///   propagation, and then pass the signal on to attached transformations if the value is not 0.
	/// \details propagation count includes this object. Setting propagation to <tt>1</tt> means this
	///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
	/// \note There should be a MessageEnd() immediately before MessageSeriesEnd().
	virtual bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);

	/// \brief Sets the default retrieval channel
	/// \param channel the channel to signal the end of a series of messages
	/// \note this function may not be implemented in all objects that should support it.
	virtual void SetRetrievalChannel(const std::string &channel);
//@}

///	\name ATTACHMENT
/// \details Some BufferedTransformation objects (e.g. Filter objects) allow other BufferedTransformation objects to be
///   attached. When this is done, the first object instead of buffering its output, sends that output to the attached
///   object as input. The entire attachment chain is deleted when the anchor object is destructed.

//@{
	/// \brief Determines whether the object allows attachment
	/// \return true if the object allows an attachment, false otherwise
	/// \details Sources and Filters will returns true, while Sinks and other objects will return false.
	virtual bool Attachable() {return false;}

	/// \brief Returns the object immediately attached to this object
	/// \return the attached transformation
	/// \details AttachedTransformation() returns NULL if there is no attachment. The non-const
	///   version of AttachedTransformation() always returns NULL.
	virtual BufferedTransformation *AttachedTransformation() {CRYPTOPP_ASSERT(!Attachable()); return NULLPTR;}

	/// \brief Returns the object immediately attached to this object
	/// \return the attached transformation
	/// \details AttachedTransformation() returns NULL if there is no attachment. The non-const
	///   version of AttachedTransformation() always returns NULL.
	virtual const BufferedTransformation *AttachedTransformation() const
		{return const_cast<BufferedTransformation *>(this)->AttachedTransformation();}

	/// \brief Delete the current attachment chain and attach a new one
	/// \param newAttachment the new BufferedTransformation to attach
	/// \throws NotImplemented
	/// \details Detach() deletes the current attachment chain and replace it with an optional newAttachment
	/// \details If a derived class does not override Detach(), then the base class throws
	///   NotImplemented.
	virtual void Detach(BufferedTransformation *newAttachment = NULLPTR) {
		CRYPTOPP_UNUSED(newAttachment); CRYPTOPP_ASSERT(!Attachable());
		throw NotImplemented("BufferedTransformation: this object is not attachable");
	}

	/// \brief Add newAttachment to the end of attachment chain
	/// \param newAttachment the attachment to add to the end of the chain
	virtual void Attach(BufferedTransformation *newAttachment);
//@}

virtual ~CryptoMaterial() {}

/// \brief Assign values to this object
/// \details This function can be used to create a public key from a private key.
virtual void AssignFrom(const NameValuePairs &source) =0;

/// \brief Check this object for errors
/// \param rng a RandomNumberGenerator for objects which use randomized testing
/// \param level the level of thoroughness
/// \returns true if the tests succeed, false otherwise
/// \details There are four levels of thoroughness:
///   <ul>
///   <li>0 - using this object won't cause a crash or exception
///   <li>1 - this object will probably function, and encrypt, sign, other operations correctly
///   <li>2 - ensure this object will function correctly, and perform reasonable security checks
///   <li>3 - perform reasonable security checks, and do checks that may take a long time
///   </ul>
/// \details Level 0 does not require a RandomNumberGenerator. A NullRNG() can be used for level 0.
///   Level 1 may not check for weak keys and such. Levels 2 and 3 are recommended.
/// \sa ThrowIfInvalid()
virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0;

/// \brief Check this object for errors
/// \param rng a RandomNumberGenerator for objects which use randomized testing
/// \param level the level of thoroughness
/// \throws InvalidMaterial
/// \details Internally, ThrowIfInvalid() calls Validate() and throws InvalidMaterial() if validation fails.
/// \sa Validate()
virtual void ThrowIfInvalid(RandomNumberGenerator &rng, unsigned int level) const
	{if (!Validate(rng, level)) throw InvalidMaterial("CryptoMaterial: this object contains invalid values");}

/// \brief Saves a key to a BufferedTransformation
/// \param bt the destination BufferedTransformation
/// \throws NotImplemented
/// \details Save() writes the material to a BufferedTransformation.
/// \details If the material is a key, then the key is written with ASN.1 DER encoding. The key
///   includes an object identifier with an algorthm id, like a subjectPublicKeyInfo.
/// \details A "raw" key without the "key info" can be saved using a key's DEREncode() method.
/// \details If a derived class does not override Save(), then the base class throws
///   NotImplemented().
virtual void Save(BufferedTransformation &bt) const
	{CRYPTOPP_UNUSED(bt); throw NotImplemented("CryptoMaterial: this object does not support saving");}

/// \brief Loads a key from a BufferedTransformation
/// \param bt the source BufferedTransformation
/// \throws KeyingErr
/// \details Load() attempts to read material from a BufferedTransformation. If the
///   material is a key that was generated outside the library, then the following
///   usually applies:
///   <ul>
///   <li>the key should be ASN.1 BER encoded
///   <li>the key should be a "key info"
///   </ul>
/// \details "key info" means the key should have an object identifier with an algorthm id,
///   like a subjectPublicKeyInfo.
/// \details To read a "raw" key without the "key info", then call the key's BERDecode() method.
/// \note Load() generally does not check that the key is valid. Call Validate(), if needed.
virtual void Load(BufferedTransformation &bt)
	{CRYPTOPP_UNUSED(bt); throw NotImplemented("CryptoMaterial: this object does not support loading");}

/// \brief Determines whether the object supports precomputation
/// \return true if the object supports precomputation, false otherwise
/// \sa Precompute()
virtual bool SupportsPrecomputation() const {return false;}

/// \brief Perform precomputation
/// \param precomputationStorage the suggested number of objects for the precompute table
/// \throws NotImplemented
/// \details The exact semantics of Precompute() varies, but it typically means calculate
///   a table of n objects that can be used later to speed up computation.
/// \details If a derived class does not override Precompute(), then the base class throws
///   NotImplemented.
/// \sa SupportsPrecomputation(), LoadPrecomputation(), SavePrecomputation()
virtual void Precompute(unsigned int precomputationStorage) {
	CRYPTOPP_UNUSED(precomputationStorage); CRYPTOPP_ASSERT(!SupportsPrecomputation());
	throw NotImplemented("CryptoMaterial: this object does not support precomputation");
}

/// \brief Retrieve previously saved precomputation
/// \param storedPrecomputation BufferedTransformation with the saved precomputation
/// \throws NotImplemented
/// \sa SupportsPrecomputation(), Precompute()
virtual void LoadPrecomputation(BufferedTransformation &storedPrecomputation)
	{CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

/// \brief Save precomputation for later use
/// \param storedPrecomputation BufferedTransformation to write the precomputation
/// \throws NotImplemented
/// \sa SupportsPrecomputation(), Precompute()
virtual void SavePrecomputation(BufferedTransformation &storedPrecomputation) const
	{CRYPTOPP_UNUSED(storedPrecomputation); CRYPTOPP_ASSERT(!SupportsPrecomputation()); throw NotImplemented("CryptoMaterial: this object does not support precomputation");}

/// \brief Perform a quick sanity check
/// \details DoQuickSanityCheck() is for internal library use, and it should not be called by library users.
void DoQuickSanityCheck() const	{ThrowIfInvalid(NullRNG(), 0);}

/// \brief Generate a random key or crypto parameters
/// \param rng a RandomNumberGenerator to produce keying material
/// \param params additional initialization parameters
/// \throws KeyingErr if a key can't be generated or algorithm parameters are invalid
/// \details If a derived class does not override GenerateRandom(), then the base class throws
///    NotImplemented.
virtual void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &params = g_nullNameValuePairs) {
	CRYPTOPP_UNUSED(rng); CRYPTOPP_UNUSED(params);
	throw NotImplemented("GeneratableCryptoMaterial: this object does not support key/parameter generation");
}

/// \brief Generate a random key or crypto parameters
/// \param rng a RandomNumberGenerator to produce keying material
/// \param keySize the size of the key, in bits
/// \throws KeyingErr if a key can't be generated or algorithm parameters are invalid
/// \details GenerateRandomWithKeySize calls GenerateRandom() with a NameValuePairs
///    object with only "KeySize"
void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize);

/// \brief Retrieves a reference to CryptoMaterial
/// \return a reference to the crypto material
virtual CryptoMaterial & AccessMaterial() =0;

/// \brief Retrieves a reference to CryptoMaterial
/// \return a const reference to the crypto material
virtual const CryptoMaterial & GetMaterial() const =0;

/// \brief Saves this object to a BufferedTransformation
/// \param bt a BufferedTransformation object
/// \details Use of DEREncode() changed to Save() at Issue 569.
/// \deprecated for backwards compatibility, calls GetMaterial().Save(bt)
void DEREncode(BufferedTransformation &bt) const
	{GetMaterial().Save(bt);}

// VC60 workaround: no co-variant return type

/// \brief Retrieves a reference to a Public Key
/// \return a reference to the public key
CryptoMaterial & AccessMaterial()
	{return AccessPublicKey();}
/// \brief Retrieves a reference to a Public Key
/// \return a const reference the public key
const CryptoMaterial & GetMaterial() const
	{return GetPublicKey();}

/// \brief Retrieves a reference to a Public Key
/// \return a reference to the public key
virtual PublicKey & AccessPublicKey() =0;
/// \brief Retrieves a reference to a Public Key
/// \return a const reference the public key
virtual const PublicKey & GetPublicKey() const
	{return const_cast<PublicKeyAlgorithm *>(this)->AccessPublicKey();}

/// \brief Retrieves a reference to a Private Key
/// \return a reference the private key
CryptoMaterial & AccessMaterial() {return AccessPrivateKey();}
/// \brief Retrieves a reference to a Private Key
/// \return a const reference the private key
const CryptoMaterial & GetMaterial() const {return GetPrivateKey();}

/// \brief Retrieves a reference to a Private Key
/// \return a reference the private key
virtual PrivateKey & AccessPrivateKey() =0;
/// \brief Retrieves a reference to a Private Key
/// \return a const reference the private key
virtual const PrivateKey & GetPrivateKey() const {return const_cast<PrivateKeyAlgorithm *>(this)->AccessPrivateKey();}

/// \brief Retrieves a reference to Crypto Parameters
/// \return a reference the crypto parameters
CryptoMaterial & AccessMaterial() {return AccessCryptoParameters();}
/// \brief Retrieves a reference to Crypto Parameters
/// \return a const reference the crypto parameters
const CryptoMaterial & GetMaterial() const {return GetCryptoParameters();}

/// \brief Retrieves a reference to Crypto Parameters
/// \return a reference the crypto parameters
virtual CryptoParameters & AccessCryptoParameters() =0;
/// \brief Retrieves a reference to Crypto Parameters
/// \return a const reference the crypto parameters
virtual const CryptoParameters & GetCryptoParameters() const {return const_cast<KeyAgreementAlgorithm *>(this)->AccessCryptoParameters();}

/// \brief Provides the maximum length of plaintext for a given ciphertext length
/// \return the maximum size of the plaintext, in bytes
/// \details This function returns 0 if ciphertextLength is not valid (too long or too short).
virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0;

/// \brief Calculate the length of ciphertext given length of plaintext
/// \return the maximum size of the ciphertext, in bytes
/// \details This function returns 0 if plaintextLength is not valid (too long).
virtual size_t CiphertextLength(size_t plaintextLength) const =0;

/// \brief Determines whether this object supports the use of a named parameter
/// \param name the name of the parameter
/// \return true if the parameter name is supported, false otherwise
/// \details Some possible parameter names: EncodingParameters(), KeyDerivationParameters()
///   and others Parameters listed in argnames.h
virtual bool ParameterSupported(const char *name) const =0;

/// \brief Provides the fixed ciphertext length, if one exists
/// \return the fixed ciphertext length if one exists, otherwise 0
/// \details "Fixed" here means length of ciphertext does not depend on length of plaintext.
///   In this case, it usually does depend on the key length.
virtual size_t FixedCiphertextLength() const {return 0;}

/// \brief Provides the maximum plaintext length given a fixed ciphertext length
/// \return maximum plaintext length given the fixed ciphertext length, if one exists,
///   otherwise return 0.
/// \details FixedMaxPlaintextLength(0 returns the maximum plaintext length given the fixed ciphertext
///   length, if one exists, otherwise return 0.
virtual size_t FixedMaxPlaintextLength() const {return 0;}

/// \brief Encrypt a byte string
/// \param rng a RandomNumberGenerator derived class
/// \param plaintext the plaintext byte buffer
/// \param plaintextLength the size of the plaintext byte buffer
/// \param ciphertext a byte buffer to hold the encrypted string
/// \param parameters a set of NameValuePairs to initialize this object
/// \pre <tt>CiphertextLength(plaintextLength) != 0</tt> ensures the plaintext isn't too large
/// \pre <tt>COUNTOF(ciphertext) == CiphertextLength(plaintextLength)</tt> ensures the output
///   byte buffer is large enough.
/// \sa PK_Decryptor
virtual void Encrypt(RandomNumberGenerator &rng,
	const byte *plaintext, size_t plaintextLength,
	byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const =0;

/// \brief Create a new encryption filter
/// \param rng a RandomNumberGenerator derived class
/// \param attachment an attached transformation
/// \param parameters a set of NameValuePairs to initialize this object
/// \details \p attachment can be \p NULL. The caller is responsible for deleting the returned pointer.
///   Encoding parameters should be passed in the "EP" channel.
virtual BufferedTransformation * CreateEncryptionFilter(RandomNumberGenerator &rng,
	BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const;

/// \brief Decrypt a byte string
/// \param rng a RandomNumberGenerator derived class
/// \param ciphertext the encrypted byte buffer
/// \param ciphertextLength the size of the encrypted byte buffer
/// \param plaintext a byte buffer to hold the decrypted string
/// \param parameters a set of NameValuePairs to initialize this object
/// \return the result of the decryption operation
/// \details If DecodingResult::isValidCoding is true, then DecodingResult::messageLength
///   is valid and holds the the actual length of the plaintext recovered. The result is undefined
///   if decryption failed. If DecodingResult::isValidCoding is false, then DecodingResult::messageLength
///   is undefined.
/// \pre <tt>COUNTOF(plaintext) == MaxPlaintextLength(ciphertextLength)</tt> ensures the output
///   byte buffer is large enough
/// \sa PK_Encryptor
virtual DecodingResult Decrypt(RandomNumberGenerator &rng,
	const byte *ciphertext, size_t ciphertextLength,
	byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const =0;

/// \brief Create a new decryption filter
/// \param rng a RandomNumberGenerator derived class
/// \param attachment an attached transformation
/// \param parameters a set of NameValuePairs to initialize this object
/// \return the newly created decryption filter
/// \note the caller is responsible for deleting the returned pointer
virtual BufferedTransformation * CreateDecryptionFilter(RandomNumberGenerator &rng,
	BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const;

/// \brief Decrypt a fixed size ciphertext
/// \param rng a RandomNumberGenerator derived class
/// \param ciphertext the encrypted byte buffer
/// \param plaintext a byte buffer to hold the decrypted string
/// \param parameters a set of NameValuePairs to initialize this object
/// \return the result of the decryption operation
/// \details If DecodingResult::isValidCoding is true, then DecodingResult::messageLength
///   is valid and holds the the actual length of the plaintext recovered. The result is undefined
///   if decryption failed. If DecodingResult::isValidCoding is false, then DecodingResult::messageLength
///   is undefined.
/// \pre <tt>COUNTOF(plaintext) == MaxPlaintextLength(ciphertextLength)</tt> ensures the output
///   byte buffer is large enough
/// \sa PK_Encryptor
DecodingResult FixedLengthDecrypt(RandomNumberGenerator &rng, const byte *ciphertext, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const
	{return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}

/// \brief Exception throw when the private or public key is too short to sign or verify
/// \details KeyTooShort() may be thrown by any function in this class if the private or public
///   key is too short to sign or verify anything
class CRYPTOPP_DLL KeyTooShort : public InvalidKeyLength
{
public:
	KeyTooShort() : InvalidKeyLength("PK_Signer: key too short for this signature scheme") {}
};

virtual ~PK_SignatureScheme() {}

/// \brief Provides the signature length if it only depends on the key
/// \return the signature length if it only depends on the key, in bytes
/// \details SignatureLength() returns the signature length if it only depends on the key, otherwise 0.
virtual size_t SignatureLength() const =0;

/// \brief Provides the maximum signature length produced given the length of the recoverable message part
/// \param recoverablePartLength the length of the recoverable message part, in bytes
/// \return the maximum signature length produced for a given length of recoverable message part, in bytes
/// \details MaxSignatureLength() returns the maximum signature length produced given the length of the
///   recoverable message part.
virtual size_t MaxSignatureLength(size_t recoverablePartLength = 0) const
{CRYPTOPP_UNUSED(recoverablePartLength); return SignatureLength();}

/// \brief Provides the length of longest message that can be recovered
/// \return the length of longest message that can be recovered, in bytes
/// \details MaxRecoverableLength() returns the length of longest message that can be recovered, or 0 if
///   this signature scheme does not support message recovery.
virtual size_t MaxRecoverableLength() const =0;

/// \brief Provides the length of longest message that can be recovered from a signature of given length
/// \param signatureLength the length of the signature, in bytes
/// \return the length of longest message that can be recovered from a signature of given length, in bytes
/// \details MaxRecoverableLengthFromSignatureLength() returns the length of longest message that can be
///   recovered from a signature of given length, or 0 if this signature scheme does not support message
///   recovery.
virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0;

/// \brief Determines whether a signature scheme requires a random number generator
/// \return true if the signature scheme requires a RandomNumberGenerator() to sign
/// \details if IsProbabilistic() returns false, then NullRNG() can be passed to functions that take
///   RandomNumberGenerator().
virtual bool IsProbabilistic() const =0;

/// \brief Determines whether the non-recoverable message part can be signed
/// \return true if the non-recoverable message part can be signed
virtual bool AllowNonrecoverablePart() const =0;

/// \brief Determines whether the signature must be input before the message
/// \return true if the signature must be input before the message during verifcation
/// \details if SignatureUpfront() returns true, then you must input the signature before the message
///   during verification. Otherwise you can input the signature at anytime.
virtual bool SignatureUpfront() const {return false;}

/// \brief Determines whether the recoverable part must be input before the non-recoverable part
/// \return true if the recoverable part must be input before the non-recoverable part during signing
/// \details RecoverablePartFirst() determines whether you must input the recoverable part before the
///   non-recoverable part during signing
virtual bool RecoverablePartFirst() const =0;

/// \warning TruncatedFinal() should not be called on PK_MessageAccumulator
void TruncatedFinal(byte *digest, size_t digestSize)
{
	CRYPTOPP_UNUSED(digest); CRYPTOPP_UNUSED(digestSize);
	throw NotImplemented("PK_MessageAccumulator: TruncatedFinal() should not be called");
}

/// \brief Create a new HashTransformation to accumulate the message to be signed
/// \param rng a RandomNumberGenerator derived class
/// \return a pointer to a PK_MessageAccumulator
/// \details NewSignatureAccumulator() can be used with all signing methods. Sign() will autimatically delete the
///   accumulator pointer. The caller is responsible for deletion if a method is called that takes a reference.
virtual PK_MessageAccumulator * NewSignatureAccumulator(RandomNumberGenerator &rng) const =0;

/// \brief Input a recoverable message to an accumulator
/// \param messageAccumulator a reference to a PK_MessageAccumulator
/// \param recoverableMessage a pointer to the recoverable message part to be signed
/// \param recoverableMessageLength the size of the recoverable message part
virtual void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const =0;

/// \brief Sign and delete the messageAccumulator
/// \param rng a RandomNumberGenerator derived class
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \param signature a block of bytes for the signature
/// \return actual signature length
/// \details Sign() deletes the messageAccumulator, even if an exception is thrown.
/// \pre <tt>COUNTOF(signature) == MaxSignatureLength()</tt>
virtual size_t Sign(RandomNumberGenerator &rng, PK_MessageAccumulator *messageAccumulator, byte *signature) const;

/// \brief Sign and restart messageAccumulator
/// \param rng a RandomNumberGenerator derived class
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \param signature a block of bytes for the signature
/// \param restart flag indicating whether the messageAccumulator should be restarted
/// \return actual signature length
/// \pre <tt>COUNTOF(signature) == MaxSignatureLength()</tt>
virtual size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const =0;

/// \brief Sign a message
/// \param rng a RandomNumberGenerator derived class
/// \param message a pointer to the message
/// \param messageLen the size of the message to be signed
/// \param signature a block of bytes for the signature
/// \return actual signature length
/// \pre <tt>COUNTOF(signature) == MaxSignatureLength()</tt>
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const;

/// \brief Sign a recoverable message
/// \param rng a RandomNumberGenerator derived class
/// \param recoverableMessage a pointer to the recoverable message part to be signed
/// \param recoverableMessageLength the size of the recoverable message part
/// \param nonrecoverableMessage a pointer to the non-recoverable message part to be signed
/// \param nonrecoverableMessageLength the size of the non-recoverable message part
/// \param signature a block of bytes for the signature
/// \return actual signature length
/// \pre <tt>COUNTOF(signature) == MaxSignatureLength(recoverableMessageLength)</tt>
virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength,
	const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const;

/// \brief Create a new HashTransformation to accumulate the message to be verified
/// \return a pointer to a PK_MessageAccumulator
/// \details NewVerificationAccumulator() can be used with all verification methods. Verify() will autimatically delete
///   the accumulator pointer. The caller is responsible for deletion if a method is called that takes a reference.
virtual PK_MessageAccumulator * NewVerificationAccumulator() const =0;

/// \brief Input signature into a message accumulator
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \param signature the signature on the message
/// \param signatureLength the size of the signature
virtual void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const =0;

/// \brief Check whether messageAccumulator contains a valid signature and message
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \return true if the signature is valid, false otherwise
/// \details Verify() deletes the messageAccumulator, even if an exception is thrown.
virtual bool Verify(PK_MessageAccumulator *messageAccumulator) const;

/// \brief Check whether messageAccumulator contains a valid signature and message, and restart messageAccumulator
/// \param messageAccumulator a reference to a PK_MessageAccumulator derived class
/// \return true if the signature is valid, false otherwise
/// \details VerifyAndRestart() restarts the messageAccumulator
virtual bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const =0;

/// \brief Check whether input signature is a valid signature for input message
/// \param message a pointer to the message to be verified
/// \param messageLen the size of the message
/// \param signature a pointer to the signature over the message
/// \param signatureLen the size of the signature
/// \return true if the signature is valid, false otherwise
virtual bool VerifyMessage(const byte *message, size_t messageLen,
	const byte *signature, size_t signatureLen) const;

/// \brief Recover a message from its signature
/// \param recoveredMessage a pointer to the recoverable message part to be verified
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \return the result of the verification operation
/// \details Recover() deletes the messageAccumulator, even if an exception is thrown.
/// \pre <tt>COUNTOF(recoveredMessage) == MaxRecoverableLengthFromSignatureLength(signatureLength)</tt>
virtual DecodingResult Recover(byte *recoveredMessage, PK_MessageAccumulator *messageAccumulator) const;

/// \brief Recover a message from its signature
/// \param recoveredMessage a pointer to the recoverable message part to be verified
/// \param messageAccumulator a pointer to a PK_MessageAccumulator derived class
/// \return the result of the verification operation
/// \details RecoverAndRestart() restarts the messageAccumulator
/// \pre <tt>COUNTOF(recoveredMessage) == MaxRecoverableLengthFromSignatureLength(signatureLength)</tt>
virtual DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &messageAccumulator) const =0;

/// \brief Recover a message from its signature
/// \param recoveredMessage a pointer for the recovered message
/// \param nonrecoverableMessage a pointer to the non-recoverable message part to be signed
/// \param nonrecoverableMessageLength the size of the non-recoverable message part
/// \param signature the signature on the message
/// \param signatureLength the size of the signature
/// \return the result of the verification operation
/// \pre <tt>COUNTOF(recoveredMessage) == MaxRecoverableLengthFromSignatureLength(signatureLength)</tt>
virtual DecodingResult RecoverMessage(byte *recoveredMessage,
	const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength,
	const byte *signature, size_t signatureLength) const;

/// \brief Provides the size of the agreed value
/// \return size of agreed value produced in this domain
virtual unsigned int AgreedValueLength() const =0;

/// \brief Provides the size of the private key
/// \return size of private keys in this domain
virtual unsigned int PrivateKeyLength() const =0;

/// \brief Provides the size of the public key
/// \return size of public keys in this domain
virtual unsigned int PublicKeyLength() const =0;

/// \brief Generate private key in this domain
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \pre <tt>COUNTOF(privateKey) == PrivateKeyLength()</tt>
virtual void GeneratePrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;

/// \brief Generate a public key from a private key in this domain
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer with the previously generated private key
/// \param publicKey a byte buffer for the generated public key in this domain
/// \pre <tt>COUNTOF(publicKey) == PublicKeyLength()</tt>
virtual void GeneratePublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;

/// \brief Generate a private/public key pair
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \param publicKey a byte buffer for the generated public key in this domain
/// \details GenerateKeyPair() is equivalent to calling GeneratePrivateKey() and then GeneratePublicKey().
/// \pre <tt>COUNTOF(privateKey) == PrivateKeyLength()</tt>
/// \pre <tt>COUNTOF(publicKey) == PublicKeyLength()</tt>
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;

/// \brief Derive agreed value
/// \param agreedValue a byte buffer for the shared secret
/// \param privateKey a byte buffer with your private key in this domain
/// \param otherPublicKey a byte buffer with the other party's public key in this domain
/// \param validateOtherPublicKey a flag indicating if the other party's public key should be validated
/// \return true upon success, false in case of failure
/// \details Agree() derives an agreed value from your private keys and couterparty's public keys.
/// \details The other party's public key is validated by default. If you have previously validated the
///   static public key, use <tt>validateStaticOtherPublicKey=false</tt> to save time.
/// \pre <tt>COUNTOF(agreedValue) == AgreedValueLength()</tt>
/// \pre <tt>COUNTOF(privateKey) == PrivateKeyLength()</tt>
/// \pre <tt>COUNTOF(otherPublicKey) == PublicKeyLength()</tt>
virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0;

/// \brief Provides the size of the agreed value
/// \return size of agreed value produced in this domain
virtual unsigned int AgreedValueLength() const =0;

/// \brief Provides the size of the static private key
/// \return size of static private keys in this domain
virtual unsigned int StaticPrivateKeyLength() const =0;

/// \brief Provides the size of the static public key
/// \return size of static public keys in this domain
virtual unsigned int StaticPublicKeyLength() const =0;

/// \brief Generate static private key in this domain
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \pre <tt>COUNTOF(privateKey) == PrivateStaticKeyLength()</tt>
virtual void GenerateStaticPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;

/// \brief Generate a static public key from a private key in this domain
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer with the previously generated private key
/// \param publicKey a byte buffer for the generated public key in this domain
/// \pre <tt>COUNTOF(publicKey) == PublicStaticKeyLength()</tt>
virtual void GenerateStaticPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;

/// \brief Generate a static private/public key pair
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \param publicKey a byte buffer for the generated public key in this domain
/// \details GenerateStaticKeyPair() is equivalent to calling GenerateStaticPrivateKey() and then GenerateStaticPublicKey().
/// \pre <tt>COUNTOF(privateKey) == PrivateStaticKeyLength()</tt>
/// \pre <tt>COUNTOF(publicKey) == PublicStaticKeyLength()</tt>
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;

/// \brief Provides the size of ephemeral private key
/// \return the size of ephemeral private key in this domain
virtual unsigned int EphemeralPrivateKeyLength() const =0;

/// \brief Provides the size of ephemeral public key
/// \return the size of ephemeral public key in this domain
virtual unsigned int EphemeralPublicKeyLength() const =0;

/// \brief Generate ephemeral private key
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \pre <tt>COUNTOF(privateKey) == PrivateEphemeralKeyLength()</tt>
virtual void GenerateEphemeralPrivateKey(RandomNumberGenerator &rng, byte *privateKey) const =0;

/// \brief Generate ephemeral public key
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \param publicKey a byte buffer for the generated public key in this domain
/// \pre <tt>COUNTOF(publicKey) == PublicEphemeralKeyLength()</tt>
virtual void GenerateEphemeralPublicKey(RandomNumberGenerator &rng, const byte *privateKey, byte *publicKey) const =0;

/// \brief Generate private/public key pair
/// \param rng a RandomNumberGenerator derived class
/// \param privateKey a byte buffer for the generated private key in this domain
/// \param publicKey a byte buffer for the generated public key in this domain
/// \details GenerateEphemeralKeyPair() is equivalent to calling GenerateEphemeralPrivateKey() and then GenerateEphemeralPublicKey()
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const;

/// \brief Derive agreed value
/// \param agreedValue a byte buffer for the shared secret
/// \param staticPrivateKey a byte buffer with your static private key in this domain
/// \param ephemeralPrivateKey a byte buffer with your ephemeral private key in this domain
/// \param staticOtherPublicKey a byte buffer with the other party's static public key in this domain
/// \param ephemeralOtherPublicKey a byte buffer with the other party's ephemeral public key in this domain
/// \param validateStaticOtherPublicKey a flag indicating if the other party's public key should be validated
/// \return true upon success, false in case of failure
/// \details Agree() derives an agreed value from your private keys and couterparty's public keys.
/// \details The other party's ephemeral public key is validated by default. If you have previously validated
///   the static public key, use <tt>validateStaticOtherPublicKey=false</tt> to save time.
/// \pre <tt>COUNTOF(agreedValue) == AgreedValueLength()</tt>
/// \pre <tt>COUNTOF(staticPrivateKey) == StaticPrivateKeyLength()</tt>
/// \pre <tt>COUNTOF(ephemeralPrivateKey) == EphemeralPrivateKeyLength()</tt>
/// \pre <tt>COUNTOF(staticOtherPublicKey) == StaticPublicKeyLength()</tt>
/// \pre <tt>COUNTOF(ephemeralOtherPublicKey) == EphemeralPublicKeyLength()</tt>
virtual bool Agree(byte *agreedValue,
	const byte *staticPrivateKey, const byte *ephemeralPrivateKey,
	const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey,
	bool validateStaticOtherPublicKey=true) const =0;

InitializeSession(rng, parameters);	// or call initialize method in derived class
while (true)
{
	if (OutgoingMessageAvailable())
	{
		length = GetOutgoingMessageLength();
		GetOutgoingMessage(message);
		; // send outgoing message
	}

	if (LastMessageProcessed())
		break;

	; // receive incoming message
	ProcessIncomingMessage(message);
}
; // call methods in derived class to obtain result of protocol session

/// Exception thrown when a function is called unexpectedly
/*! for example calling ProcessIncomingMessage() when ProcessedLastMessage() == true */
class UnexpectedMethodCall : public Exception
{
public:
	UnexpectedMethodCall(const std::string &s) : Exception(OTHER_ERROR, s) {}
};

virtual ~ProtocolSession() {}

ProtocolSession() : m_rng(NULLPTR), m_throwOnProtocolError(true), m_validState(false) {}

virtual void InitializeSession(RandomNumberGenerator &rng, const NameValuePairs &parameters) =0;

bool GetThrowOnProtocolError() const {return m_throwOnProtocolError;}
void SetThrowOnProtocolError(bool throwOnProtocolError) {m_throwOnProtocolError = throwOnProtocolError;}

bool HasValidState() const {return m_validState;}

virtual bool OutgoingMessageAvailable() const =0;
virtual unsigned int GetOutgoingMessageLength() const =0;
virtual void GetOutgoingMessage(byte *message) =0;

virtual bool LastMessageProcessed() const =0;
virtual void ProcessIncomingMessage(const byte *message, unsigned int messageLength) =0;

RandomNumberGenerator *m_rng;

virtual unsigned int GetAgreedValueLength() const =0;
virtual void GetAgreedValue(byte *agreedValue) const =0;

void InitializePasswordAuthenticatedKeyAgreementSession(RandomNumberGenerator &rng,
	const byte *myId, unsigned int myIdLength,
	const byte *counterPartyId, unsigned int counterPartyIdLength,
	const byte *passwordOrVerifier, unsigned int passwordOrVerifierLength);

/// return whether the domain parameters stored in this object are valid
virtual bool ValidateDomainParameters(RandomNumberGenerator &rng) const
	{return GetCryptoParameters().Validate(rng, 2);}

virtual unsigned int GetPasswordVerifierLength(const byte *password, unsigned int passwordLength) const =0;
virtual void GeneratePasswordVerifier(RandomNumberGenerator &rng, const byte *userId, unsigned int userIdLength, const byte *password, unsigned int passwordLength, byte *verifier) const =0;

enum RoleFlags {CLIENT=1, SERVER=2, INITIATOR=4, RESPONDER=8};

virtual bool IsValidRole(unsigned int role) =0;
virtual PasswordAuthenticatedKeyAgreementSession * CreateProtocolSession(unsigned int role) const =0;

/// \brief Decode this object from a BufferedTransformation
/// \param bt BufferedTransformation object
/// \details Uses Basic Encoding Rules (BER)
virtual void BERDecode(BufferedTransformation &bt) =0;

/// \brief Encode this object into a BufferedTransformation
/// \param bt BufferedTransformation object
/// \details Uses Distinguished Encoding Rules (DER)
virtual void DEREncode(BufferedTransformation &bt) const =0;

/// \brief Encode this object into a BufferedTransformation
/// \param bt BufferedTransformation object
/// \details Uses Basic Encoding Rules (BER).
/// \details This may be useful if DEREncode() would be too inefficient.
virtual void BEREncode(BufferedTransformation &bt) const {DEREncode(bt);}

/// \brief Construct a FileStore
FileStore() : m_stream(NULLPTR), m_space(NULLPTR), m_len(0), m_waiting(0) {}

/// \brief Construct a FileStore
/// \param in an existing stream
FileStore(std::istream &in) : m_stream(NULLPTR), m_space(NULLPTR), m_len(0), m_waiting(0)
	{StoreInitialize(MakeParameters(Name::InputStreamPointer(), &in));}

/// \brief Construct a FileStore
/// \param filename the narrow name of the file to open
FileStore(const char *filename) : m_stream(NULLPTR), m_space(NULLPTR), m_len(0), m_waiting(0)
	{StoreInitialize(MakeParameters(Name::InputFileName(), filename ? filename : ""));}

/// \brief Retrieves the internal stream
/// \returns the internal stream pointer
std::istream* GetStream() {return m_stream;}

/// \brief Retrieves the internal stream
/// \returns the internal stream pointer
const std::istream* GetStream() const {return m_stream;}

lword MaxRetrievable() const;
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
lword Skip(lword skipMax=ULONG_MAX);

member_ptr<std::ifstream> m_file;
std::istream *m_stream;
byte *m_space;
size_t m_len;
bool m_waiting;

/// \brief Construct a FileSource
FileSource(BufferedTransformation *attachment = NULLPTR)
	: SourceTemplate<FileStore>(attachment) {}

/// \brief Construct a FileSource
/// \param in an existing stream
/// \param pumpAll flag indicating if source data should be pumped to its attached transformation
/// \param attachment an optional attached transformation
FileSource(std::istream &in, bool pumpAll, BufferedTransformation *attachment = NULLPTR)
	: SourceTemplate<FileStore>(attachment) {SourceInitialize(pumpAll, MakeParameters(Name::InputStreamPointer(), &in));}

/// \brief Construct a FileSource
/// \param filename the narrow name of the file to open
/// \param pumpAll flag indicating if source data should be pumped to its attached transformation
/// \param attachment an optional attached transformation
/// \param binary flag indicating if the file is binary
FileSource(const char *filename, bool pumpAll, BufferedTransformation *attachment = NULLPTR, bool binary=true)
	: SourceTemplate<FileStore>(attachment) {SourceInitialize(pumpAll, MakeParameters(Name::InputFileName(), filename)(Name::InputBinaryMode(), binary));}

/// \brief Retrieves the internal stream
/// \returns the internal stream pointer
std::istream* GetStream() {return m_store.GetStream();}

/// \brief Construct a FileSink
FileSink() : m_stream(NULLPTR) {}

/// \brief Construct a FileSink
/// \param out an existing stream
FileSink(std::ostream &out)
	{IsolatedInitialize(MakeParameters(Name::OutputStreamPointer(), &out));}

/// \brief Construct a FileSink
/// \param filename the narrow name of the file to open
/// \param binary flag indicating if the file is binary
FileSink(const char *filename, bool binary=true)
	{IsolatedInitialize(MakeParameters(Name::OutputFileName(), filename)(Name::OutputBinaryMode(), binary));}

/// \brief Retrieves the internal stream
/// \returns the internal stream pointer
std::ostream* GetStream() {return m_stream;}

void IsolatedInitialize(const NameValuePairs &parameters);
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking);
bool IsolatedFlush(bool hardFlush, bool blocking);

///	\name ATTACHMENT
//@{

/// \brief Construct a Filter
/// \param attachment an optional attached transformation
/// \details attachment can be \p NULL.
Filter(BufferedTransformation *attachment = NULLPTR);

/// \brief Determine if attachable
/// \returns \p true if the object allows attached transformations, \p false otherwise.
/// \note Source and Filter offer attached transformations; while Sink does not.
bool Attachable() {return true;}

/// \brief Retrieve attached transformation
/// \returns pointer to a BufferedTransformation if there is an attached transformation, \p NULL otherwise.
BufferedTransformation *AttachedTransformation();

/// \brief Retrieve attached transformation
/// \returns pointer to a BufferedTransformation if there is an attached transformation, \p NULL otherwise.
const BufferedTransformation *AttachedTransformation() const;

/// \brief Replace an attached transformation
/// \param newAttachment an optional attached transformation
/// \details newAttachment can be a single filter, a chain of filters or \p NULL.
///    Pass \p NULL to remove an existing BufferedTransformation or chain of filters
void Detach(BufferedTransformation *newAttachment = NULLPTR);

//@}

// See the documentation for BufferedTransformation in cryptlib.h
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;

// See the documentation for BufferedTransformation in cryptlib.h
void Initialize(const NameValuePairs &parameters=g_nullNameValuePairs, int propagation=-1);
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true);
bool MessageSeriesEnd(int propagation=-1, bool blocking=true);

virtual bool ShouldPropagateMessageEnd() const {return true;}
virtual bool ShouldPropagateMessageSeriesEnd() const {return true;}

void PropagateInitialize(const NameValuePairs &parameters, int propagation);

/// \brief Forward processed data on to attached transformation
/// \param outputSite unknown, system crash between keyboard and chair...
/// \param inString the byte buffer to process
/// \param length the size of the string, in bytes
/// \param messageEnd means how many filters to signal MessageEnd() to, including this one
/// \param blocking specifies whether the object should block when processing input
/// \param channel the channel to process the data
/// \returns the number of bytes that remain in the block (i.e., bytes not processed)
size_t Output(int outputSite, const byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel=DEFAULT_CHANNEL);

/// \brief Output multiple bytes that may be modified by callee.
/// \param outputSite unknown, system crash between keyboard and chair...
/// \param inString the byte buffer to process
/// \param length the size of the string, in bytes
/// \param messageEnd means how many filters to signal MessageEnd() to, including this one
/// \param blocking specifies whether the object should block when processing input
/// \param channel the channel to process the data
/// \returns the number of bytes that remain in the block (i.e., bytes not processed)
size_t OutputModifiable(int outputSite, byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel=DEFAULT_CHANNEL);

/// \brief Signals the end of messages to the object
/// \param outputSite unknown, system crash between keyboard and chair...
/// \param propagation the number of attached transformations the  MessageEnd() signal should be passed
/// \param blocking specifies whether the object should block when processing input
/// \param channel the channel to process the data
/// \returns TODO
/// \details propagation count includes this object. Setting  propagation to <tt>1</tt> means this
///   object only. Setting propagation to <tt>-1</tt> means unlimited propagation.
bool OutputMessageEnd(int outputSite, int propagation, bool blocking, const std::string &channel=DEFAULT_CHANNEL);

/// \brief Flush buffered input and/or output, with signal propagation
/// \param outputSite unknown, system crash between keyboard and chair...
/// \param hardFlush is used to indicate whether all data should be flushed
/// \param propagation the number of attached transformations the  Flush() signal should be passed
/// \param blocking specifies whether the object should block when processing input
/// \param channel the channel to process the data
/// \returns TODO
/// \details propagation count includes this object. Setting  propagation to <tt>1</tt> means this
///   object only. Setting  propagation to <tt>-1</tt> means unlimited propagation.
/// \note Hard flushes must be used with care. It means try to process and output everything, even if
///   there may not be enough data to complete the action. For example, hard flushing a  HexDecoder
///   would cause an error if you do it after inputing an odd number of hex encoded characters.
/// \note For some types of filters, like  ZlibDecompressor, hard flushes can only
///   be done at "synchronization points". These synchronization points are positions in the data
///   stream that are created by hard flushes on the corresponding reverse filters, in this
///   example ZlibCompressor. This is useful when zlib compressed data is moved across a
///   network in packets and compression state is preserved across packets, as in the SSH2 protocol.
bool OutputFlush(int outputSite, bool hardFlush, int propagation, bool blocking, const std::string &channel=DEFAULT_CHANNEL);

/// \brief Marks the end of a series of messages, with signal propagation
/// \param outputSite unknown, system crash between keyboard and chair...
/// \param propagation the number of attached transformations the  MessageSeriesEnd() signal should be passed
/// \param blocking specifies whether the object should block when processing input
/// \param channel the channel to process the data
/// \returns TODO
/// \details Each object that receives the signal will perform its processing, decrement
///    propagation, and then pass the signal on to attached transformations if the value is not 0.
/// \details propagation count includes this object. Setting  propagation to <tt>1</tt> means this
///   object only. Setting  propagation to <tt>-1</tt> means unlimited propagation.
/// \note There should be a MessageEnd() immediately before MessageSeriesEnd().
bool OutputMessageSeriesEnd(int outputSite, int propagation, bool blocking, const std::string &channel=DEFAULT_CHANNEL);

/// \brief Create a working space in a BufferedTransformation
/// \param target BufferedTransformation for the working space
/// \param channel channel for the working space
/// \param minSize minimum size of the allocation, in bytes
/// \param desiredSize preferred size of the allocation, in bytes
/// \param bufferSize actual size of the allocation, in bytes
/// \pre <tt>desiredSize >= minSize</tt> and <tt>bufferSize >= minSize</tt>.
/// \details \p bufferSize is an IN and OUT parameter. If HelpCreatePutSpace() returns a non-NULL value, then
///    bufferSize is valid and provides the size of the working space created for the caller.
/// \details Internally, HelpCreatePutSpace() calls \ref BufferedTransformation::ChannelCreatePutSpace
///   "ChannelCreatePutSpace()" using \p desiredSize. If the target returns \p desiredSize with a size less
///   than \p minSize (i.e., the request could not be fulfilled), then an internal SecByteBlock
///   called \p m_tempSpace is resized and used for the caller.
byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize)
{
	CRYPTOPP_ASSERT(desiredSize >= minSize && bufferSize >= minSize);
	if (m_tempSpace.size() < minSize)
	{
		byte *result = target.ChannelCreatePutSpace(channel, desiredSize);
		if (desiredSize >= minSize)
		{
			bufferSize = desiredSize;
			return result;
		}
		m_tempSpace.New(bufferSize);
	}

	bufferSize = m_tempSpace.size();
	return m_tempSpace.begin();
}

/// \brief Create a working space in a BufferedTransformation
/// \param target the BufferedTransformation for the working space
/// \param channel channel for the working space
/// \param minSize minimum size of the allocation, in bytes
/// \details Internally, the overload calls HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize) using \p minSize for missing arguments.
byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize)
	{return HelpCreatePutSpace(target, channel, minSize, minSize, minSize);}

/// \brief Create a working space in a BufferedTransformation
/// \param target the BufferedTransformation for the working space
/// \param channel channel for the working space
/// \param minSize minimum size of the allocation, in bytes
/// \param bufferSize the actual size of the allocation, in bytes
/// \details Internally, the overload calls HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t desiredSize, size_t &bufferSize) using \p minSize for missing arguments.
byte *HelpCreatePutSpace(BufferedTransformation &target, const std::string &channel, size_t minSize, size_t bufferSize)
	{return HelpCreatePutSpace(target, channel, minSize, minSize, bufferSize);}

/// \brief Temporay working space
SecByteBlock m_tempSpace;

/// \brief Construct a MeterFilter
/// \param attachment an optional attached transformation
/// \param transparent flag indicating if the filter should function transparently
/// \details \p attachment can be \p NULL. The filter is transparent by default. If the filter is
///   transparent, then PutMaybeModifiable() does not process a request and always returns 0.
MeterFilter(BufferedTransformation *attachment=NULLPTR, bool transparent=true)
	: m_transparent(transparent), m_currentMessageBytes(0), m_totalBytes(0)
	, m_currentSeriesMessages(0), m_totalMessages(0), m_totalMessageSeries(0)
	, m_begin(NULLPTR), m_length(0) {Detach(attachment); ResetMeter();}

/// \brief Set or change the transparent mode of this object
/// \param transparent the new transparent mode
void SetTransparent(bool transparent) {m_transparent = transparent;}

/// \brief Adds a range to skip during processing
/// \param message the message to apply the range
/// \param position the 0-based index in the current stream
/// \param size the length of the range
/// \param sortNow flag indicating whether the range should be sorted
/// \details Internally, MeterFilter maitains a deque of ranges to skip. As messages are processed,
///   ranges of bytes are skipped according to the list of ranges.
void AddRangeToSkip(unsigned int message, lword position, lword size, bool sortNow = true);

/// \brief Resets the meter
/// \details ResetMeter() reinitializes the meter by setting counters to 0 and removing previous
///   skip ranges.
void ResetMeter();

void IsolatedInitialize(const NameValuePairs &parameters)
	{CRYPTOPP_UNUSED(parameters); ResetMeter();}

lword GetCurrentMessageBytes() const {return m_currentMessageBytes;}
lword GetTotalBytes() const {return m_totalBytes;}
unsigned int GetCurrentSeriesMessages() const {return m_currentSeriesMessages;}
unsigned int GetTotalMessages() const {return m_totalMessages;}
unsigned int GetTotalMessageSeries() const {return m_totalMessageSeries;}

byte * CreatePutSpace(size_t &size)
	{return AttachedTransformation()->CreatePutSpace(size);}
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking);
size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking);
bool IsolatedMessageSeriesEnd(bool blocking);

struct MessageRange
{
	inline bool operator<(const MessageRange &b) const	// BCB2006 workaround: this has to be a member function
		{return message < b.message || (message == b.message && position < b.position);}
	unsigned int message; lword position; lword size;
};

bool m_transparent;
lword m_currentMessageBytes, m_totalBytes;
unsigned int m_currentSeriesMessages, m_totalMessages, m_totalMessageSeries;
std::deque<MessageRange> m_rangesToSkip;
byte *m_begin;
size_t m_length;

/// \brief Construct a FilterWithBufferedInput with an attached transformation
/// \param attachment an attached transformation
FilterWithBufferedInput(BufferedTransformation *attachment);

/// \brief Construct a FilterWithBufferedInput with an attached transformation
/// \param firstSize the size of the first block
/// \param blockSize the size of middle blocks
/// \param lastSize the size of the last block
/// \param attachment an attached transformation
/// \details \p firstSize and \p lastSize may be 0. \p blockSize must be at least 1.
FilterWithBufferedInput(size_t firstSize, size_t blockSize, size_t lastSize, BufferedTransformation *attachment);

void IsolatedInitialize(const NameValuePairs &parameters);
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
{
	return PutMaybeModifiable(const_cast<byte *>(inString), length, messageEnd, blocking, false);
}

size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
{
	return PutMaybeModifiable(inString, length, messageEnd, blocking, true);
}

/// \brief Flushes data buffered by this object, without signal propagation
/// \param hardFlush indicates whether all data should be flushed
/// \param blocking specifies whether the object should block when processing input
/// \details IsolatedFlush() calls ForceNextPut() if hardFlush is true