/*
	dd if=/dev/urandom of=./key.dat bs=1024 count=1
*/
$key = file_get_contents("./key.dat");
$ct = floor(time()/30);
echo hash_hmac("sha1",$ct,$key)."\n";
 

function hotp($key,$c)	{
	$mask = ['f' => '7','e' => '6','d' => '5','c' => '4','b' => '3','a' => '2','9' => '1','8' => '0'];
	$hash_value_str = hash_hmac("sha1",pack("H*",sprintf("%016x",$c)),$key);
	$offset = intval($hash_value_str[39],16)*2;
	$extract = substr($hash_value_str,$offset,8);
	if(isset($mask[$extract[0]]))	{
		$extract[0] = $mask[$extract[0]];
	}
	$value = intval($extract,16);
	return ($value % 1000000);
}

$ct = floor(time()/30);
$key = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";	
printf("%06d\n",hotp($key,$ct));
 

$token = hash("sha256",random_bytes(32));

<?php
	$cipher = 'AES-256-CBC';							//SUIT de cirado utilizada 
	$strkey = "s3cr3tk3yh4x0r";							//Clave en el servidor, secreta, cambiar esta clave de ejemplo POR FAVOR de preferencia utilizar una clave generada de forma segura con openssl_random_pseudo_bytes o /dev/random
	$realkey = hash("sha256",$strkey,true);						//Hash de la clave en formato Raw
	$ivlen = openssl_cipher_iv_length($cipher);					// Obtenemos el tamaño del Vector Inicializado de acuardo a la Suit de cifrado que estemos utilizando
	$iv = openssl_random_pseudo_bytes($ivlen);					// Obtenemos $ivlen bytes random no nos interesa saber su valor
	$token = hash("sha256",random_bytes(32));	//Token sin cifrar este valor nuca lo ve el UserAgent
	$token_cifrado = openssl_encrypt($token,$cipher,$realkey,OPENSSL_RAW_DATA,$iv); 
	$salida = base64_encode($token_cifrado);					//Este valor si lo ve el User Agent
	echo "token: ".$token."\n";
	echo "token cifrado, salida raw: ".$token_cifrado ."\n";
	echo "token cifrado, salida base64: ".$salida."\n";
	$entrada = base64_decode($salida);
	$token_decifrado = openssl_decrypt($entrada,$cipher,$realkey,OPENSSL_RAW_DATA,$iv);
	echo "token decifrado: ".$token_decifrado ."\n";
	if($token_decifrado == $token)	{
		echo "token correcto\n";
	}
	else	{
		echo "token Incorrecto\n";
	}
?>

token: 5ab8aac170554a2683e0cc0534a34e80d0f16031a13faa3c3a5ee44902b2c6a1
token cifrado, salida raw: 
CU
?!,F8C4d1su
        SN{|큮vDjUa=qQKKKȀE#(@/I
token cifrado, salida base64: AUO6plUB9j8h+IvsyixGOAfZQzRkCzG84XN1vN7X2Aq2CVNOont87YGudsJEq2q1VWE9vZhxqJWfUUviv0tL9ciA+kWTI74oGEAvl4sSSak=
token decifrado: 5ab8aac170554a2683e0cc0534a34e80d0f16031a13faa3c3a5ee44902b2c6a1
token correcto

<h4>Deja un comentario</h4>
<p></small>Tu dirección de correo electrónico no será publicada. <b>Los campos obligatorios están marcados con *</b></small></p>
<div class="form-group">
	<label for="exampleInputUsername">Nombre *</label>
	<input type="text" class="form-control" id="exampleInputUsername" aria-describedby="usernameHelp">
	<small id="usernameHelp" class="form-text text-muted">Nombre para mostrar, este campo si va a ser mostrado</small>
</div>
<div class="form-group">
	<label for="exampleInputEmail">Correo Electronico *</label>
	<input type="email" class="form-control" id="exampleInputEmail1" aria-describedby="emailHelp">
	<small id="emailHelp" class="form-text text-muted">Tu direccion de correo electronico no sera publicada</small>
</div>
<div class="form-group">
	<label for="exampleInputWEB">WEB *</label>
	<input type="text" class="form-control" id="exampleInputWEB" aria-describedby="webHelp">
	<small id="webHelp" class="form-text text-muted">Direccion WEB Segura valida ejemplo: https://www.example.com/</small>
</div>
<div class="form-group">
	<label for="exampleTextAreaComentario">Comentario *</label>
	<textarea class="form-control" id="exampleTextAreaComentario" rows="5" aria-describedby="comentarioHelp"></textarea>
	<small id="comentarioHelp" class="form-text text-muted">Todos los comentarios seran moderados antes de ser publicados</small>
</div>
<div class="form-group form-check">
	<input type="checkbox" class="form-check-input" id="exampleCheckboxSubscribe">
	<label class="form-check-label" for="exampleCheckboxSubscribe">Recibir notificaciones de Respuestas a tus comentarios</label>
</div>
<button type="button" class="btn btn-primary">Publicar Comentario</button>
<button type="button" class="btn btn-secondary">Vista Previa</button>
<div id="comentario_vista_previa">
</div>
 
 

<?php
try {
  //Validar datos POST or GET aqui.
  $post_data = http_build_query(
    array(
        'secret' => "SECRET KEY HERE THIS VALUE MUST BE PRIVATE...",
        'response' => $_POST['reCAPTCHA_Token'],//Token devuelto por Google al Front End y enviado a este formulario
        'remoteip' => $_SERVER['REMOTE_ADDR'] //Direccion IP publica del cliente que envia el formulario
    )
  );
  $opts = array('http' =>
    array(
    'method'  => 'POST',
    'header'  => 'Content-type: application/x-www-form-urlencoded',
    'content' => $post_data
    )
  );
  $context  = stream_context_create($opts);
  $response = file_get_contents('https://www.google.com/recaptcha/api/siteverify', false, $context);	
  $result = json_decode($response);
  if($result->action != $_POST["action"])	{
    throw new Exception("Google recaptcha action missmatch");
  }
  if($result->score < 0.5)	{
    throw new Exception("Google recaptcha score too low");
  }
  //Devuelta a las validaciones actuales de seguridad para los datos recibidos 
}catch(Exception $e) {
  //catch exception here
}
?>

function local_search()	{
	$.ajax({
		async: true,
		type: "GET",
		accepts: "application/json",
		url: "/api/search",
		data:	{ s: $("#input_str").value },
		success: function (result)	{
			alert(result.ok);
		}
	});
}
 

<div>
	<input id="input_str" type="text">
	<button onclick="local_search();">Buscar</button>
</div>
 

Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0
Accept: undefined
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://localhost/
X-Requested-With: XMLHttpRequest
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache

		data:	{ s: $("#input_str").value },

[code]		data:	{ s: $("#input_str").val() },

			fseek(contenido,offset,SEEK_SET);
			leido = fread(buffer,1,size,contenido);
			printf("Leido %i %s\n",leido,path);
			if(leido != size)	{
				fprintf(stderr,"fread() read %i vs request %i\n",leido,size);
				exit(0);
			}
			fclose(contenido);
 

int send_all(SOCKET descriptor, const void *buffer, size_t length, int flags)	{
	printf("send_all\n");
    ssize_t n;
    const char *p = buffer;
    while (length > 0)
    {
        n = send(descriptor, p, length, flags);
		printf("send: %i bytes\n",n);
        if (n <= 0)
            return -1;
        p += n;
        length -= n;
    }
    return 0;
}
 

int send_all(SOCKET descriptor, const void *buffer, int length, int flags)	{
	int n,s;
	const char *p = buffer;
	while (length > 0)	{
		s = ( length > 64 ) ? 64: length; 
		n = send(descriptor, p, s, flags);
		if (n <= 0)
			return -1;
		p += n;
		length -= n;
	}
	return 0;
}

/*
 El tipo de dato se puede cambiar dependiendo de la implementación que se le quiera dar, también se tendrían que cambiar los tipos de datos devueltos por las funciones
 En este caso yo quería un arreglo de apuntadores char* por lo cual el contenedor es char**
 */
 
 
typedef struct str_queue	{
	char **queue;
	int len;
	int max;
}Queue;	
 
Queue *create_queue()	{
	Queue *r = malloc(sizeof(struct str_queue));
	r->len = 0;
	r->max = 2;
	r->queue = malloc(sizeof(char*)*r->max);
	return r;
}
 
void free_queue(Queue *q)	{
	if(q)	{
		if(q->queue)
			free(q->queue);
		free(q);
	}
}
 
void en_queue(Queue *q, char *ptr)	{
	if((q->len+1) == q->max)	{
		q->max *= 2;
		q->queue = realloc(q->queue,q->max*sizeof(char*));	
	}
	if(q->queue != NULL)	{
		q->queue[q->len] = ptr;
		q->len++;
	}
}
 
char * de_queue(Queue *q)	{
	char *r = NULL;
	int i = 0;
	if(q->len >= 1)	{
		r = q->queue[0];
		q->len--;
		while(i < q->len)	{
			q->queue[i] = q->queue[i+1];
			i++;
		}
		q->queue[i] = NULL;
	}
	return r;
}

int main()	{
	char *cadenas[10] = { "Cadena_0","Cadena_1","Cadena_2","Cadena_3","Cadena_4","Cadena_5","Cadena_6","Cadena_7","Cadena_8","Cadena_9"};
	char *actual;
	int index1,index2,i =0;
	srand(time(NULL));
	Queue *q = create_queue();
	while(i < 10)	{
		index1 = rand() % 10;
		index2 = rand() % 10;
		printf("Agregando a la fila: %s\n",cadenas[index1]);
		en_queue(q,cadenas[index1]);
		printf("Agregando a la fila: %s\n",cadenas[index2]);
		en_queue(q,cadenas[index2]);
		printf("Saliendo de la fila %s\n",de_queue(q));
		i++;
	}
	free_queue(q);
}
 

Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_2
Agregando a la fila: Cadena_9
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_1
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_0
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_4
Agregando a la fila: Cadena_0
Saliendo de la fila Cadena_9
Agregando a la fila: Cadena_7
Agregando a la fila: Cadena_1
Saliendo de la fila Cadena_2

char * de_queue(Queue *q)	{
	char *r = NULL;
	int i = 0;
	if(q->len >= 1)	{
		r = q->queue[0];
		q->len--;
		while(i < q->len)	{
			q->queue[i] = q->queue[i+1];
			i++;
		}
		q->queue[i] = NULL;
	}
	return r;
}
 

directorio_archivo_temporal = readdir(directorio)

while(directorio_archivo_temporal = readdir(directorio) )	{
	//etc..
	free(directorio_archivo_temporal);
}
 

#include<sys/stat.h>
#include<sys/types.h>
#include<dirent.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
int is_regular_file(const char *path);
 
int procesar_directorio(char *path);
 
int main(int argc,char **argv)	{
	switch(argc){
		case 2:	//Se espera directorio
			procesar_directorio(argv[1]);
		break;
		default:
			printf("Numero de argumentos no esperado\n");
		break;
	}
	getchar();
 
}
 
int is_regular_file(const char *path)	{
	struct stat path_stat;
	stat(path, &path_stat);
	return S_ISREG(path_stat.st_mode);
}
 
int procesar_directorio(char *path)	{
	DIR *directorio;
	struct dirent *directorio_archivo_temporal;
	char *path_copy;
	int len_path;
	char *path_temporal;
	int len_path_temporal;
	directorio = opendir(path);
	if(directorio != NULL)	{	
		len_path = strlen(path);
		path_copy = malloc(len_path+2);
		memcpy(path_copy,path,len_path);
		if(path_copy[len_path - 1] == '\\' ){
			path_copy[len_path] = '\0';
		}
		else	{
			path_copy[len_path] = '\\';
			path_copy[len_path+1] = '\0';
			len_path++;
		}
		while(directorio_archivo_temporal = readdir(directorio) )	{		
			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
			path_temporal = malloc(len_path+len_path_temporal+1);
			path_temporal[len_path+len_path_temporal] = '\0';
			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
			if(is_regular_file(path_temporal))	{
				printf("%s\n",path_temporal);
			}
			else	{	//Directorio?
				if( len_path_temporal > 2 ) { //not .. or .
					procesar_directorio(path_temporal);	//recursivamente
				}			
			}
			free(path_temporal);
		}
		free(path_copy);
		closedir(directorio);
	}
}
 

#include<sys/stat.h>
#include<sys/types.h>
#include<dirent.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
int fsize(const char *filename);
int is_regular_file(const char *path);
 
int procesar_directorio(char *path,char *virtual_path);
 
int main(int argc,char **argv)	{
	switch(argc){
		case 2:	//Se espera directorio
			procesar_directorio(argv[1],"/");
		break;
		case 3:	//Se espera archivo + nombre de directorio de destino.
		break;
		default:
			printf("Numero de argumentos no esperado\n");
		break;
	}
	getchar();
 
}
 
int is_regular_file(const char *path)	{
	struct stat path_stat;
	stat(path, &path_stat);
	return S_ISREG(path_stat.st_mode);
}
 
int fsize(const char *filename) {
    struct stat st;
    if (stat(filename, &st) == 0)
        return st.st_size;
    return -1; 
}
 
int procesar_directorio(char *path,char *virtual_path)	{
	DIR *directorio;
	struct dirent *directorio_archivo_temporal,*result;
 
	char *path_copy;
	char *virtual_path_copy;
	int len_path,len_virtual_path;
 
	char *path_temporal;
	char *virtual_path_temporal;
	int len_path_temporal;
	int len_virtual_path_temporal;
 
 
	directorio = opendir(path);
	if(directorio != NULL)	{	
 
		len_path = strlen(path);
		len_virtual_path = strlen(virtual_path);
 
		virtual_path_copy = malloc(len_virtual_path+2);
		path_copy = malloc(len_path+2);
		memcpy(path_copy,path,len_path);
		memcpy(virtual_path_copy,virtual_path,len_virtual_path);
 
		if(path_copy[len_path - 1] == '\\' ){
			path_copy[len_path] = '\0';
		}
		else	{
			path_copy[len_path] = '\\';
			path_copy[len_path+1] = '\0';
			len_path++;
		}
		if(virtual_path_copy[len_virtual_path - 1] == '/' ){
			virtual_path_copy[len_virtual_path] = '\0';
		}
		else	{
			virtual_path_copy[len_virtual_path] = '/';
			virtual_path_copy[len_virtual_path+1] = '\0';
			len_virtual_path++;
		}
		/*
		directorio_archivo_temporal = calloc(1,sizeof(struct dirent));
		result == NULL;
		*/
		//while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
		while(directorio_archivo_temporal = readdir(directorio) )	{
 
			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
			//printf("readdir point to %p\n",directorio_archivo_temporal);
			//printf("Len %i : %s\n",len_path_temporal,directorio_archivo_temporal->d_name);
 
			path_temporal = malloc(len_path+len_path_temporal+1);
			virtual_path_temporal = malloc(len_virtual_path + len_path_temporal+1);
 
			path_temporal[len_path+len_path_temporal] = '\0';
			virtual_path_temporal[len_virtual_path+len_path_temporal] = '\0';
 
			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
			sprintf(virtual_path_temporal,"%s%s",virtual_path_copy,directorio_archivo_temporal->d_name);
 
			if(is_regular_file(path_temporal))	{
				//printf("Archivo :\"%s\"\n",path_temporal);
				printf("%s\n",virtual_path_temporal);
			}
			else	{	//Directorio?
				if( len_path_temporal > 2 ) { //not .. or .
					procesar_directorio(path_temporal,virtual_path_temporal);	//recursivamente
				}			
			}
			free(path_temporal);
			free(virtual_path_temporal);
		}
		//free(directorio_archivo_temporal);
 
 
 
		free(path_copy);
		free(virtual_path_copy);
		closedir(directorio);
	}
	else	{
		printf("El directorio \"%s\" no es un directorio valido\n",path);
	}
}
 

C:\>generar_contenido.exe contenido
/index.html

while(directorio_archivo_temporal = readdir(directorio) )	{
	//etc...
}
 

while(directorio_archivo_temporal = readdir(directorio) )	{
	//etc..
	free(directorio_archivo_temporal);
}
 

while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){