#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define MYPORT 4500 //Puerto que se deja a la escucha
#define NUBACK 5 //Numero maximo de conexiones a la espera.

int main()
{
int nSocket;
int nSocket2;
int nListen;
struct sockaddr_in my_dire;
struct sockaddr_in su_dire;
int sin_zero;

if ((nSocket=socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("[-] Socket");
exit(1);
}
my_dire.sin_family = AF_INET;
my_dire.sin_port = htons(MYPORT);
my_dire.sin_addr.s_addr = htonl(INADDR_ANY);
memset(&(my_dire.sin_zero), '\0', 8);
if (bind(nSocket, (struct sockaddr *)&my_dire, sizeof(struct sockaddr)) == -1)
{
perror("[-] Bind");
exit(1);
}
if ((nListen=listen(nSocket, NUBACK)) == -1)
{
perror("[-] Listen");
exit(1);
}
printf("[+] Listen iniciado.\n");
printf("\t-Escuchando el puerto %d.\n", MYPORT);
printf("\t-Esperando una conexion.\n");
sin_zero = sizeof(struct sockaddr_in);
if ((nSocket2=accept(nSocket, (struct sockaddr *)&su_dire, &sin_zero)) == -1)
{
perror("[-] Accept");
exit(1);
}
printf("[+] Conexion realizada.\n");
close(nSocket);
return 0;
}

#include <stdio.h>
#include <netinet/in.h>

int main() {

struct sockaddr_in saddr;
int hsock;

hsock=socket(AF_INET,SOCK_STREAM,0);
if (hsock<0) {
printf("Error creando el socket\n");
return -1;
}
saddr.sin_family=AF_INET;
saddr.sin_addr.s_addr=INADDR_ANY;
saddr.sin_port=htons(4500);
if (bind(hsock,(struct sockaddr *)&saddr,sizeof(saddr))<0) {
printf("Bind error\n");
return -1;
}
if (listen(hsock,1)<0) {
printf("Listen error\n");
return -1;
}
accept(hsock,0,0);
printf("FIN\n");
return 0;
}

/*
   Nombre: b64
   Autor: Thezen
   Mail/msn: putoamo@gmail.com
   Descripcion: Aplicacion que permite Codificar/Descodificar en Base64
                Para codificar, añadirle el parámetro /c y para descodificar
                /d seguido de una cadena.
*/
   

#include <stdio.h>
#include <string.h>
#include <math.h>

int binario[1024];
int btd[8];
int cont=0;

char base64[] = { 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
                  'P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d',
                  'e','f','g','h','i','j','k','l','m','n','o','p','q','r','s',
                  't','u','v','w','x','y','z','0','1','2','3','4','5','6','7',
                  '8','9','+','/' };

void atob(int num, int base); /* Convierte un valor ASCII a binario */
int btod( int base ); /* Convierte un valor binario a decimal */
void codificar(char *clave); /* Codifica una cadena a Base64 */
void descodificar(char *clave); /* Descodifica una cadena en Base64 */

int main(int argc, char *argv[])
{
    printf(" *--------------------------------------------*\n");
    printf("  \\   Codificador/Descodificador de Base64   /\n");
    printf("  /   By: TheZen    -    putoamo@gmail.com   \\ \n");
    printf(" *--------------------------------------------*\n");
   
    if( argc != 3 )
    {
        printf("\n Modo de uso: %s [/c /d] clave. \n",argv[0]);
        printf(" /c [cadena] - Codifica una cadena\n");
        printf(" /d [cadena] - Descodifica una cadena\n");
        exit( 1 );
    }
   
    if( (strcmp(argv[1],"/c")==0) || (strcmp(argv[1],"/C")==0) ) codificar(argv[2]);
    if( (strcmp(argv[1],"/d")==0) || (strcmp(argv[1],"/D")==0) ) descodificar(argv[2]);
   
    printf("\n");
}

/*************************************************************************/

void codificar(char *clave)
{
    int x=0, num, contador, b64, z=0;
    char clave2[1024];
                     
    sprintf(clave2,"%s",clave);
   
    while( 1 )
    {
        num = clave2[x];
        if(num==0) break;
        atob(num,8);
        x++;
        contador++;
    }   
    printf("\n");
    num=0;
    for(x=0;x<=((8*(contador-2)-1));x++)
        num++;
         
    cont=0;
    while( (num%6) != 0 )
        num++;
    num /= 6;
   
    printf("  [*] Codificado a Base64: ");
    for( x=1 ; x<=num ; x++ )
    {
        for( z=0 ; z<=5 ; z++ ){
            btd[z] = binario[cont];
            cont++;
        }   
        b64=btod(6);
        printf("%c",base64[b64]);   
    } 
    while( (num%4)!=0 ){
        printf("=");   
        num++;
    }   
} 

/*************************************************************************/

void descodificar(char *clave)
{
    char clave2[1024], deci;
    int x=0, z=0, decimal[1024], num, contador=0, dec;
                     
    sprintf(clave2,"%s",clave);
   
    while( clave[z] != '=' )
    {
        if( (clave2[z]==0) || (clave2[z]=='=') ) break;
        for( x=0 ; x<=64 ; x++ )
            if( base64[x] == clave2[z] ) decimal[z] = x;
        z++;
    }
    x=0;
    while( 1 )
    {
        num = decimal[x];
        if(num==0) break;
        atob(num,6);
        x++;
        contador++;
    }   
   
    num = 6*contador;
    num /= 8;
    printf("  [*] Descodificado en Base64: ");
    cont=0;
    for( x=1 ; x<=num ; x++ )
    {
        for( z=0 ; z<=7 ; z++ ){
            btd[z] = binario[cont];
            cont++;
        }   
        dec = btod(8);
        printf("%c",dec,dec); 
    }
}   

/**************************************************************************/

void atob(int num, int base)
{
    int bin[base];
    int x=0;
   
    for( x=0 ; x<=(base-1) ; x++ )
    {
        bin[x] = num % 2;
        num /= 2;
    }
    for( x=(base-1) ; x>=0 ; x-- ){
        binario[cont] = bin[x];
        cont++;
    }   
}

/**************************************************************************/

int btod( int base )
{
    int b64=0;
    int x=0,z=0;
   
    for( x=(base-1) ; x>=0 ; x-- ){
        b64 += btd[x] * pow(2,z);
        z++;
    }     
    return b64;
}   

/*************************************************************************/