Funte: Como crear un formulario de comentarios para tu web

Pues nada lo primero es tener el Formulario en HTML.
Posterior mente el javascript para validar el formulario antes de enviarlo
El script en el Backend para volver a validar los datos.
El metodo de almacenamiento del comentario (Base de datos)
Un sistema para evitar que saturen de comentarios basura
Y al final pero mas importante EVITAR SER HACKEADO (xss, sql, file inclusion etc etc etc etc etc)

El codigo en HTML para el formulario utilizando Boostrap:

<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>
 
 

Resultado:

Fuente Utilizar reCAPTCHA v3 para evitar intentos de fuerza bruta

En el Post que acabo de publicar básicamente se muestra el código en javascript y en PHP para implementar el reCAPTCHA v3 en un Formulario para evitar ataques de fuerza bruta.

Codigo en PHP:

<?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
}
?>

saludos!

Hola que tal espero y me puedan ayudar, tengo un error de lo mas tonto. Sin embargo no se por que el jquery no esta enviando el data mediante Ajax.

JS

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);
		}
	});
}
 

HTML:

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

Puedo ver que si hace la peticion al servidor, pero no envia nunca la data

RAW Request

---

Solución

Codigo Incorrecto

Codigo Correcto

[/code]

Dear ......

We are writing to let you know that we recently discovered that some user data was compromised as a result of unauthorized access to our systems by a malicious third party. We are very sorry for any concern or inconvenience this may cause. We are working rapidly to investigate the situation further and take the appropriate steps to prevent such incidents in the future.

What Happened

On Friday we discovered that some user data was compromised by a third party who gained unauthorized access to our systems. We're still investigating the precise causes and in addition to the work being conducted by our internal security teams, we have retained a leading digital forensics and security firm to assist us. We have also notified law enforcement officials.

While the investigation is still ongoing, we have already taken steps to contain the incident, and our efforts to protect our users and prevent this type of incident from happening in the future are our top priority as a company.

What information was involved

The following information of yours may have been compromised:

    Account and user information, e.g. name, email, IP, user ID, encrypted password, user account settings, personalization data

    Public actions and content including drafts, e.g. questions, answers, comments, blog posts, upvotes

    Data imported from linked networks when authorized by you, e.g. contacts, demographic information, interests, access tokens (now invalidated)

Questions and answers that were written anonymously are not affected by this breach as we do not store the identities of people who post anonymous content.

What we are doing

While our investigation continues, we're taking additional steps to improve our security:

    We’re in the process of notifying users whose data has been compromised.
    Out of an abundance of caution, we are logging out all Quora users who may have been affected, and, if they use a password as their authentication method, we are invalidating their passwords.
    We believe we’ve identified the root cause and taken steps to address the issue, although our investigation is ongoing and we’ll continue to make security improvements.

We will continue to work both internally and with our outside experts to gain a full understanding of what happened and take any further action as needed.

What you can do

We’ve included more detailed information about more specific questions you may have in our help center, which you can find here.

While the passwords were encrypted (hashed with a salt that varies for each user), it is generally a best practice not to reuse the same password across multiple services, and we recommend that people change their passwords if they are doing so.

Conclusion

It is our responsibility to make sure things like this don’t happen, and we failed to meet that responsibility. We recognize that in order to maintain user trust, we need to work very hard to make sure this does not happen again. There’s little hope of sharing and growing the world’s knowledge if those doing so cannot feel safe and secure, and cannot trust that their information will remain private. We are continuing to work very hard to remedy the situation, and we hope over time to prove that we are worthy of your trust.

The Quora Team

Muy buen dia.

Estoy trabajando con un servidor http de lo mas básico posible.

Tengo un error al momento de enviar el contenido. El navegador a veces recibe los archivos incompletos y no logro ubicar el error.



El navegador indica que solo recibe 768KB para el penultimo archivo "/test.mp3"

La salida del programa indica lo siguiente para ese archivo.



Leido indica la cantidad de bytes que a leido desde el archivo:

			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);
 

leido toma la cantidad que devuelve fread, si leido y size son distintos el programa termina inmediatamente.


Posteriormente mando ese buffer leido al comando send.

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;
}
 

send all indica mediante la variable "n" la cantidad de datos enviados por send.

Asi mismo en los headers recibe correctamente el mismo numero indicado por el programa:



Asi que dado que la cantidad de items leidos por fread es la misma que la cantidad de bytes enviados por send, no entiendo por que el navegador no recibe todo el archivo, ya que al momento de tratar de reproducirlo esta incompleto.

Saludos

---

Al final quedo solucionado modificando la funcion send all. Por alguna razon dice que a enviado todos lo 2 MB pero el navegador  solo recibio los 700 KB. Modique la funcion para que envie de 64 bytes por vez y ahora envio el documento completo

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;
}

Y el programa marca exactamente la misma cantidad.


Saludos!

No es lo mas eficiente, hay muchas cosas se podrian mejorar, en especifico la forma en la que se organizan  el arreglo de elementos actuales en la Fila,  sin embargo funciono para el proposito.

Yo se que la mayoría de estas estructuras ya están implementadas. Pero no se puede decir que eres programador si no sabes implementarlas por tu cuenta.

/*
 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;
}

Yo en su momento lo utilize para un post, donde realizaba una versión iterativa y necesitaba almacenar en una Cola el listado de los directorios que aun faltaba por recorrer:

problema de memoria con readdir (Solucionado)

Ejemplo de uso:

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);
}
 

Como es randon la salida es variada, pero podemos observar el funcionamiento:

---

Funcion actualizada de de_queue

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;
}
 

Muy buen dia.

Problema: La memoria utilizada por el programa aumenta y no disminuye

Solución: No es un problema, es la memoria que se genera por el paradigma de la recursividad, esto es: que al llamar a la misma función de forma recursiva, el Stack Frame de la memoria que utiliza cada una de las llamadas a la función se acumule.

Intente aplicar una solucion de forma Iterativa, guardando el Path de los directorios que faltan por leer en una Queue, pero utiliza mas memoria  que la solucion recursiva.

readdir devuelve un apuntador de la estructura (struct dirent)
Mas info: https://linux.die.net/man/3/readdir

El cual creo que es el causante de este POST.

Versión Corta

¿Quien controla el Apuntador entregado por readdir?

Es memoria estatica y no se debe de liberar

directorio_archivo_temporal = readdir(directorio)

Al momento de tratar de liberar dicho apuntador, el programa se cuelga...

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

El problema radica en que la memoria del programa solo aumenta y no disminuye.

Codigo de la version corta funcionando

#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);
	}
}
 

---

Versión extensa

Aquí esta toda la Letanía

Estoy realizando un programa que lea de forma Recursiva un directorio dado y liste los archivos en pantalla. Nada del otro mundo. Asi mismo estoy haciendo que el formato de salida sea el formato tipo UNIX /bla/bla/bla en lugar del formato de windows C:\lalala\lalalala.txt

Esto con el objetivo de virtualizar el path de subdirectorios específicos para otro programa pero eso ya es harina de otro costal.

El problema es que cuando listo Cualquier carpeta con muchos subdirectorios como la unidad C:\  el programa en empieza usando lo clasico unos 400 KB y termina utilizando 800 KB o mas dependiendo de la carpeta que este listada.

El dia Ayer publique un post parecido:
Problema de memoria en miniservidor usando Winsock (Solucionado)

En el cual se estaba cerrando el socket de forma incorrecta.

En este caso creo que es problema del apuntador devuelto por readdir.

Código del programa funcionando:

#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);
	}
}
 

Funciona bien, recibe parametros de entrada, ejemplo

Ejemplo


Le agregue un getchar al final del archivo para poder ver con cuanta memoria termina el programa. Para carpetas sin tanto subdirecorio no hay problema, el detalle es cuando se trata de todo un disco...

Imagen:


Ya he validado que todos los apuntadores que yo genero de forma dinámica son liberados en su totalidad, esto mediante re implementaciones de malloc,calloc,realloc y free como describo en el siguiente post: ¿He liberado todos los apuntadores?

Imagen:


Con lo cual considero que el problema es el apuntador devuelto por readdir.

Intente cambiar el siguiente pedazo de codigo

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

por

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

Pero el programa se queda colgado por un rato y finaliza, seguramente por tratar de escribir en memoria que no esta asignada...

Intente implementarlo con readdir_r utilizando mi propio apuntador previamente asignado..

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

Pero por alguna razon MinGW no lo tiene implementado, y segun he visto ya esta deprecated, entonces ¿Cual puede ser la solución?

Saludos!

---

Pordon por el Post tan largo, aqui esta su patata

Estoy haciendo pruebas con un miniservidor, que actualmente solo lee la entrada y la muestra en pantalla.



El detalle esta en que La memoria utilizada no deja de incrementar, empieza el programa usando sobre 400 KB y mientras mas preciono F5 en el navegardor WEB, (El miniservidor es WEB), enviando Multiples GET al servidor la memoria del programa incrementa y nunca decrementa, siendo que en cada ocasion he liberado el apuntador utilizado para leer la linea, y he cerrado el socket del cliente:

Codigo:

#include<winsock2.h>
#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>
 
#define BACKLOG 256
 
WSADATA *wsaData;
struct sockaddr_in *server_sa;
 
char *readLine(SOCKET descriptor,int *len);
 
int main()	{
	SOCKET s,c;
	int b = 0,iResult;
	int read_len;
	char *linea;
	char caracter;
	wsaData = calloc(1,sizeof(WSADATA));
	iResult = WSAStartup(MAKEWORD(2,2), wsaData);
	if (iResult != 0) {
		printf("WSAStartup failed: %d\n", iResult);
		return 1;
	}
	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		perror("socket");
		return 2;
	}
	server_sa = calloc(1,sizeof(struct sockaddr_in));
	server_sa->sin_family = AF_INET;
	server_sa->sin_port   = htons(80);
	server_sa->sin_addr.s_addr = htonl(INADDR_ANY);	
 
	if (bind(s,(struct sockaddr *) server_sa, sizeof(struct sockaddr)) < 0) {
		perror("bind");
		return 3;
	}
	b = sizeof(struct sockaddr);
	listen(s, BACKLOG);
	while(1)	{
		if((c = accept(s,(struct sockaddr *)server_sa, &b)) < 0) {
			printf("WS error code: %i\n",WSAGetLastError());
			perror("accept");
			return 4;
		}
		do{
			linea = readLine(c,&read_len);
			printf("%s\n",linea);
			free(linea);
		}while(read_len != 0);
		close(c);
	}
}
 
char *readLine(SOCKET descriptor,int *len)	{
	char *buffer = NULL;
	int i = 0,entrar = 1,len_read;
	do	{
		buffer = realloc(buffer,(i+1));
		len_read = recv(descriptor,buffer + i,1,0);
		if(len_read == 1){
			switch(buffer[i])	{
				case 0xD:
					buffer[i] = '\0';
				break;
				case 0xA:
					buffer[i] = '\0';
					entrar = 0;
				break;
				default:
					i++;
				break;
			}
		}
		else	{
			buffer[i] = '\0';
			entrar = 0;
		}
	}while(entrar);
	if(len  != NULL){
		len[0] = i;
	}
	return buffer;
}
 

El problema es que se espera que el servidor se lo mas liguero ligero posible y atienda millones de peticiones por segundo. Y no creo que el F5 del navegador supere mas de 100 peticiones por segundo.

Saludos

Hola a todos anteriormente ya habia trabajado con sockets en C, sin embargo no estoy seguro si es mi Computadora actual la del problema:

#include<winsock2.h>
#include<stdio.h>
 
int main()	{
	int s;
	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		printf("Valor %i\n",s);
		perror("socket");
        return 1;
	}
}
 

En mi caso al compilar y ejecutar el codigo anterior siempre me devuelve menos -1


El codigo original es mas extenso, pero incluso con ese fragmento basico de codigo me devulve error...

Version de gcc

Voy a tratar de actualizar el mingw

Saludos

Realice un programa que pueda recibir parámetros desde la linea de comandos, dicho programa recibirá un directorio en el disco duro o un archivo

Si es Directorio..

• Comprobar que el directorio sea valido.
• Comprobar que sea distinto al directorio actual.
• Listar los archivos y pesos en bytes en el directorio mencionado.
• Realizar una copia de seguridad de dichos archivos, con las siguientes características
• Todos lo archivos del directorio se deben de guardar en un unico archivo llamado directorio.dir donde directorio se debe sustituir por el nombre  del directo indicado en primer lugar. Ejemplo "C:\temp\codigos\" el archivo se debe de llamar codigos.dir
• Se debera de tener un registro  también en archivo (index.dat), que contenga Nombre, donde comienza y cuando espacio ocupa cada archivo del directorio en el nuevo.
• Se debera realizar también una validación tipo checkum de cada archivo, utilice el sistema Hash de su preferencia para hacer esta validación.

Si es archivo, deberá de ser alguno en terminación .dir

• Comprobar que exista
• Que este completo segun la lista de archivos que previamente guardamos en el index.dat
• Debera de Extraerlo en un directorio indicado por el usuario (En un segundo parametro al programa) distinto al directorio Original.

El programa podrá ser creado en C o C++

Deberá de utilizar en cualquier momento la menor cantidad de memoria posible y ser lo bastante rápido para pode competir con otros.

El post es solo para darle un poco mas de movimiento a este subforo de programación en C/C++.

Si tienen dudas sobre una parte en especifico, pueden de preferencia abrir un nuevo tema, con la duda en especifico.

Si alguno quiere participar comentelo aqui, asi mismo también pueden sugerir mas features para el programa. Ya que opciones hay varias.

La intención no es reinventar la rueda, programas similares ya existen Tipo (TAR), la intención es que quien este aprendiendo C o C++ pueda retarse asi mismo con algo que en un futuro pueda reutilizar. Y no se diga la experiencia.

Saludos