void CifradoCersar(){

	char frase[1024];
	char *p=getenv("USER");

	int lfrase;
	int n;
	int dif;

	printf("\n [>>] Cual la frase que quieres cifrar \n");
	printf("  %s~$: ",p);
	scanf("%s", frase);

	printf("\n [>>] Cuantos espacios se corraran los digitos? \n");
	printf("  %s~$: ",p);
	scanf("%d", &n);

	dif = 26 - n;
	lfrase = strlen(frase);
	/* UBYN */

	int i;
	while (i == lfrase ){
		if(frase[i] + n > 'z'){
			frase[i] = frase[i] - dif;
		}
		else{
			frase[i] = frase[i] + n;
		}
		i++;
	}

	printf("\n   [>>] La frase cifrada es  : ");
	printf("%s", frase);
	i = 0;

	while (frase[i] != '\0'){
		if(frase[i] - n < 'a'){
			frase[i] = frase[i] + dif;
		}
		else{
			frase[i] = frase[i] - n;
		}
		i++;
	}

	printf("\n   [>>] La frase original es : ");
	printf("%s\n",frase);

}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>

#define PUERTO 15560
#define MAXCLIENT 3


int shell(int sock_client, struct sockaddr_in client, struct sockaddr_in server);

int main(){

    fd_set rfds;        // Conjunto de descriptores a vigilar
    
    int sock_host;
    int sock_client;

    int childpid;
    int codigo_de_salida;
    int childcount = 0;
    int pidstatus;

    socklen_t longclient;
    
    sock_host = socket(AF_INET,SOCK_STREAM,0);
    
    struct sockaddr_in server, client;
    bzero((char *)&server, sizeof(server));
    server.sin_family       = AF_INET; 
    server.sin_port         = htons(PUERTO);
    server.sin_addr.s_addr  = INADDR_ANY;

    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 500;    //Tiempo de espera
     
    if(bind(sock_host, (struct sockaddr *)&server, sizeof(server)) < 0){ //asignamos un puerto al socket
        printf("  [!!]Error al asociar el puerto a la conexion\n");
        close(sock_host);
        return 1;
    }

    if(listen(sock_host, 10) == -1){
        printf("  [!!]No se pude escuchar en el puerto seleccionado\n");
    }
    
    longclient = sizeof(client);
    while(free){

        //Selec se carga con el valor de rfds

        FD_ZERO(&rfds);
        FD_SET(sock_host, &rfds);

        if(select(sock_host+1, &rfds, NULL, NULL, &tv)){
            if(sock_client = accept(sock_host, (struct sockaddr *)&client, &longclient) != -1){

            	printf("[>>] Conectando con %s\n", inet_ntoa(client.sin_addr));
                switch (childpid = fork()){
                    case -1:
                        printf("  [!!]Error al crear el thread\n");break;
                    case  0:
                        if(childcount < MAXCLIENT){
                        	shell(sock_client, client, server);
                        }else{
                        	printf("  [!!]Ya estas conectado");
                        }
                        break;
                    default:
                        childcount++;
                        close(sock_client);
                        break;
                }
            }else{
                printf("  [!!]Error al intentar aceptar la conexion\n");
            }
        }
        childpid = waitpid(0, &pidstatus, WNOHANG);

        if(childpid>0){
            childcount--;    //Acaba de desconectarse un cliente
        }
    }
    return 0;
}

int shell(int sock_client, struct sockaddr_in client, struct sockaddr_in server){

	char comando[512];

	char *pc	 = getenv("COMPUTERNAME");
	char *user 	 = getenv("USER");
	char os[512] = "Aun no se hacer eso. \n";
	char *ip = inet_ntoa(server.sin_addr);

	sleep(1);

	printf("  [>>] En la funcion shell\n");

	write(sock_client, "    [>>] Listo para recivir informacion \n",42); 

	while(free){

		bzero(comando, 512);
		read(sock_client, comando, strlen(comando));
		printf("%s",comando );

		if(strncmp(comando, "info", 4) == 0){

			printf("[>>] Enviando la informacion\n");

			send(sock_client, pc, strlen(pc),0);
			send(sock_client, user, strlen(user),0);
			send(sock_client, os, strlen(os), 0);
			send(sock_client, ip, strlen(ip),0);

		}
	}
	return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
     
#define BUFFSIZE 1
#define PUERTO 15560
     
int shell (int sock_client, struct sockaddr_in client);
     
int main(){
     
    char buffer[512];
    int sock_client;
    sock_client = socket(AF_INET,SOCK_STREAM,0);
     
    struct hostent *server;
    server = gethostbyname("localhost");
     
    struct sockaddr_in client;
    bzero((char *)&client, sizeof(client));
    client.sin_family       = AF_INET;
    client.sin_port         = htons(PUERTO);
    client.sin_addr     = *((struct in_addr *)server->h_addr);
     
    if(connect(sock_client,(struct sockaddr *)&client, sizeof(client)) < 0){
        printf("Error al conectar con el host\n");
        return 1;
    }

    printf("[>>] Conectando con %s",inet_ntoa(client.sin_addr));
    printf("\n");
   	
    read(sock_client, buffer, 512);

   	shell(sock_client, client);
	printf("%s", buffer);
}

int shell(int sock_client, struct sockaddr_in client){

	char command[512];

	char help[512]	= "help";
	char close[512] = "close";
	char info[512]	= "info";
	char clear[512]	= "clear";
	char HELP[1024] = "\n  [HELP MENU] \n    [HELP - Muestra este menu]\n    [Close - Cierra el menu]\n    [Info - Muestra informacion del target]\n    [Clear - Limpea la terminal ]\n\n";

	char PC[512];
	char USER[512];
	char OS[512];
	char IP[512];

	char *p = getenv("USER");
	printf(" [>>] Sesion de Shell iniciada. \n");
	read(sock_client, command, 512);
	printf("%s", command );

	while(free){
		printf("   %s@%s:~$ ",p , inet_ntoa(client.sin_addr));
		bzero(command, 512);
		fgets(command, 512 , stdin);

		write(sock_client, command, 512);
		printf("%s", command);

		if(strncmp(command,help,4) == 0){
			printf("%s",HELP);
		}
		if(strncmp(command,close,5) == 0){
			write(sock_client, close , strlen(close));
			printf("[>>] Cerrardo... \n");
			exit(1);
		}
		if(strncmp(command,info,4) == 0){
			printf("    [>>]Esperando la informacion. \n");

			read(sock_client, PC,   512);
			read(sock_client, USER, 512);
			read(sock_client, OS,   512);
			read(sock_client, IP,   512);

			printf("      El PC es    -- %s\n", PC    );
			printf("      El USER es  -- %s\n", USER  );
			printf("      El OS es    -- %s\n", OS    );
			printf("      la IP es    -- %s\n\n", IP  );	

		}
		if(strncmp(command,clear,5) == 0){
			system("clear");
		}
	}
	return 0;
}

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>

#define PUERTO     2000
int main(){
    socklen_t longc;
    int socket_host;
    int socket_cliente;

    char buffer[512];

    socket_host = socket(AF_INET, SOCK_STREAM,0);

    struct sockaddr_in servidor, cliente;
    bzero((char * )&servidor, sizeof(servidor));

    servidor.sin_family = AF_INET;
    servidor.sin_port   = htons(PUERTO);
    servidor.sin_addr.s_addr = INADDR_ANY;  

    if(bind(socket_host,(struct sockaddr *)&servidor, sizeof(servidor)) == -1){
        printf("Error en el bind\n");
        return 1;
    }
    printf("Direccion %s:%d\n", inet_ntoa(servidor.sin_addr), htons(PUERTO));
    listen(socket_host, 2);

    while(free){
        longc = sizeof(cliente); // TAMANO DE LA ESTRUCTURA CLIENTE
        socket_cliente = accept(socket_host,(struct sockaddr *)&cliente, &longc);
        printf("Escuchando en el puerto %d\n", ntohs(cliente.sin_port));

        recv(socket_cliente,buffer,512,0);
        printf("%s",buffer);
        send(socket_cliente,"listo\n",7,0);
    }
    return 0;
}

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/sendfile.h>               //Sirve para poder enviar archivos
#include <sys/types.h>                  //Sirve para poder recivir archivos
#include <linux/if_packet.h>
#include <net/if.h>                     // Cliente en cuention 
     
#define BUFFSIZE 1
#define ERROR -1
#define BUFFERSIZE 512

// Funciones //
     
int login(int socket_cliente);
void direccip(int socket_cliente, struct sockaddr_in addr);
void salir(int socket_servidor, int socket_cliente);
void enviar(int socket_cliente, FILE* archivo);
int intentos = 0; 
     
int main(){
 
    int socket_servidor;            //Socket del servidor para escuchar mensajes
    int socket_cliente;             //Socket del cliente para enviar mesajes
    int puerto = 8080;                //Numero de puerto en /etc/service
    char BUFFER[BUFFERSIZE];        //Mensaje para usar los comandos

    socket_servidor = socket(AF_INET, SOCK_STREAM, 0);
    socklen_t longc;

   // Declaracion de las escructuras;
    struct sockaddr_in servidor, cliente;                   //Creamos las estructuras del cliente y servidor al mismo tiempo
    bzero((char *)&servidor, sizeof(servidor));             //Primero llenamos de 0's la struct
    servidor.sin_family = AF_INET;                          //Asiganamos la estructura
    servidor.sin_port = htons(puerto);                      //Indicamos el puerto 
    servidor.sin_addr.s_addr = INADDR_ANY;                  //Esta macro especifica nuestra direccion
     
    if(bind(socket_servidor, (struct sockaddr *)&servidor, sizeof(servidor)) < 0){ //asignamos un puerto al socket
        printf("Error al asociar el puerto a la conexion\n");
        return 1;
    }
            
    listen(socket_servidor,3);                              //Escuchamos por este puero maximo 2 clientes distintos
    while(free){
        intentos = 0;
        printf("Escuchando en el puerto %d\n", ntohs(servidor.sin_port));
        longc = sizeof(cliente);                                //Asignamos el tamano de la estructura a esta variable
        socket_cliente = accept(socket_servidor, (struct sockaddr *)&cliente, &longc); // Esperamos una conexion
        if(socket_cliente == -1){
            printf("Error en al conexion\n");
         return 1;
        }
        printf("Conectando con %s:%d\n",inet_ntoa(cliente.sin_addr),htons(cliente.sin_port));
     
    //Login con el servidor
        int conexion = login(socket_cliente);
        printf("\n");
        if(conexion == 1){
            while(free){
                bzero(BUFFER, BUFFERSIZE);
                recv(socket_cliente,BUFFER,50,0);
                if(strncmp(BUFFER,"IP",2) == 0){
                    direccip(socket_cliente, cliente);
                }
                if(strncmp(BUFFER,"EXIT", 4) == 0){
                    salir(socket_servidor, socket_cliente);
                }
            }
        }
    }
}

int login(int socket_cliente){
           
    char user[8];
    char pass[8];

    if(intentos == 3){
        close(socket_cliente);
        return 0;
    }

    memset(user,0 , 8);
    memset(pass,0 , 8);
    printf("%i",intentos );
    printf("\n");

     
    send(socket_cliente,"Usuario: ",10,0);
    read(socket_cliente,user,9);
    send(socket_cliente, "Contrasena: ", 12, 0);
    read(socket_cliente, pass, 8);
     
    if(strncmp(user, "root",4) == 0){ 
        if(strncmp(pass, "root",4) == 0){
            send(socket_cliente,"Bienvenido\n",12,0);
        }else{
            send(socket_cliente,"ERROR\n",7,0);
            intentos = intentos + 1;
            login(socket_cliente);
        }
    }else{
        send(socket_cliente,"ERROR\n",7,0);
        intentos = intentos + 1;
        login(socket_cliente);
    }
}
     
void direccip(int socket_cliente, struct sockaddr_in addr){
    write(socket_cliente, "Tu eres: ",9);
    write(socket_cliente, inet_ntoa(addr.sin_addr), 16);
    write(socket_cliente,"\n",2);
}

void salir(int socket_servidor, int socket_cliente){
    write(socket_cliente, "ADIOS ;)\n", 10);
    close(socket_cliente);
}

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/sendfile.h>		//Sirve para poder enviar archivos
#include <sys/types.h>			//Sirve para poder recivir archivos
#include <linux/if_packet.h>
#include <sys/ioctl.h>			// Estas 2 librerias son para poder saber algunos datos sobre el
#include <net/if.h>				// Cliente en cuention 

#define BUFFSIZE 1
#define ERROR -1

// Funciones //

void login(int socket_cliente, char user[9], char pass[8]);
void direccip(int socket_cliente, struct sockaddr_in addr);
void salir(int socket_servidor, int socket_cliente);
void enviar(int socket_cliente, FILE* archivo);

int main(){

	int socket_servidor;		//Socket del servidor para escuchar mensajes
	int socket_cliente;			//Socket del cliente para enviar mesajes
	int puerto = 15560;			//Numero de puerto en /etc/service
	char indicered[100];		//Inidece de red
	char texto[50];				//Mensaje para usar los comandos
	char pass[8];				//Contrasena
	char user[9];				//Usuario
	FILE * archivo;				//Archivo sin formato

	socket_servidor = socket(AF_INET, SOCK_STREAM, 0);
	socklen_t longc;

	// Declaracion de las escructuras;
	struct sockaddr_in servidor, cliente;		//Creamos las estructuras del cliente y servidor al mismo tiempo
	bzero((char *)&servidor, sizeof(servidor)); //Primero llenamos de 0's la struct
	servidor.sin_family = AF_INET;				//Asiganamos la estructura
	servidor.sin_port = htons(puerto);			//Indicamos el puerto 
	servidor.sin_addr.s_addr = INADDR_ANY;		//Esta macro especifica nuestra direccion

	if(bind(socket_servidor, (struct sockaddr *)&servidor, sizeof(servidor)) < 0){ //asignamos un puerto al socket
   		printf("Error al asociar el puerto a la conexion\n");
    	return 1;
	}
	listen(socket_servidor,3);				//Escuchamos por este puero maximo 2 clientes distintos
	printf("Escuchando en el puerto %d\n", ntohs(servidor.sin_port));
	longc = sizeof(cliente);				//Asignamos el tamano de la estructura a esta variable
	socket_cliente = accept(socket_servidor, (struct sockaddr *)&cliente, &longc); // Esperamos una conexion
	if(socket_cliente == -1){
		printf("Error en al conexion\n");
		return 1;
	}
	printf("Conectando con %s:%d\n",inet_ntoa(cliente.sin_addr),htons(cliente.sin_port));

	//Login con el servidor

	login(socket_cliente, user, pass);

	//Hablar con el servidor

	while(free){
		bzero(texto, sizeof(texto));
		recv(socket_cliente,texto,50,0);
		if(strncmp(texto,"IP",2) == 0){
			direccip(socket_cliente, cliente);
		}
		if(strncmp(texto,"EXIT", 4) == 0){
			salir(socket_servidor, socket_cliente);
		}
		if(strncmp(texto,"DESCARGAR", 9) == 0){
			enviar(socket_cliente, archivo);
		}
	}
}
void login(int socket_cliente, char user[9], char pass[8]){
        int intentos = 0;
	bzero(user, 9);
	bzero(pass, 8);

	 if(intentos == 3){
		close(socket_cliente);
	}

	send(socket_cliente,"Usuario: ",10,0);
	read(socket_cliente,user,9);
	send(socket_cliente, "Contrasena: ", 12, 0);
	read(socket_cliente, pass, 8);

	if(strncmp(user, "frijolito",9) == 0 && strncmp(pass, "abc12345",8) == 0){
	}
	else{
		send(socket_cliente,"Error\n", 7,0);
		intentos = intentos + 1;
		login(socket_cliente, user, pass);	
	}
}

void direccip(int socket_cliente, struct sockaddr_in addr){
    write(socket_cliente, "Tu eres: ",9);
    write(socket_cliente, inet_ntoa(addr.sin_addr), 16);
    write(socket_cliente,"\n",2);
}
void salir(int socket_servidor, int socket_cliente){
	write(socket_cliente, "ADIOS ;)\n", 10);
	close(socket_servidor);
	close(socket_servidor);
	exit(1);
}
void enviar(int socket_cliente, FILE * archivo){
	char buffer[BUFFSIZE];
	char mensaje[80];
	archivo = fopen("lena.png", "rb");
	if(!archivo){
		printf("Error al abrir el archivo\n");
		send(socket_cliente,"error al abrir el archivo",26,0);
	}
	while(!feof(archivo)){
		fread(buffer,sizeof(char),BUFFSIZE, archivo);
		if(send(socket_cliente,buffer,BUFFSIZE,0) == ERROR){
			perror("Error al enviar el arvhivo:");
		}
	}
}