sec@ansicoder ~$ cat .bashrc

# Check for an interactive session
[ -z "$PS1" ] && return

alias ls='ls --color=auto'

PS1='[\u@\h \W]\$ '

PS1='\[\e[1;32m\][\u@\h \W]\$\[\e[0m\] '

Negro       0;30     Gris Obscuro  1;30
Azul        0;34     Azul Claro    1;34
Verde       0;32     Verde Claro   1;32
Cyan        0;36     Cyan Claro    1;36
Rojo        0;31     Rojo Claro    1;31
Purpura     0;35     Fiuscha       1;35
Café        0;33     Amarillo      1;33
Gris Claro  0;37     Blanco        1;37

PS1='\[\e[0;32m\]\u\[\e[m\] \[\e[1;34m\]\w\[\e[m\] \[\e[1;32m\]\$\[\e[m\] \[\e[1;37m\]'

PS1='\[\e[0;31m\]\u\[\e[m\] \[\e[1;34m\]\w\[\e[m\] \[\e[0;31m\]\$ \[\e[m\]\[\e[0;32m\]'

~/.dir_colors

if [[ -f ~/.dir_colors ]] ; then
	eval $(dircolors -b ~/.dir_colors)
fi

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  

int end(int group)  

boolean find()  

boolean find(int start)  

String group()  

String group (int group)  

static Pattern compile (String expreg)  

static Pattern compile(String regex, int flags)  

int flags ()  

Matcher matcher(CharSequence input)

static boolean matches(String regex, CharSequence input)  

String pattern()  

String [] split (CharSequence input)  

import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
  
public class regexpjava {  
  
       public static void main(String[] args) {  
  
           Pattern pat=null;  
           Matcher mat=null;  
           String texto="<title>Hola soy el titulo</title>";  
           pat=Pattern.compile("<title>(.*?)</title>");  
           mat=pat.matcher(texto);  
           System.out.println("Texto \t\t\t: "+texto);  
           if(mat.find()){  
  
               System.out.println("Expresion regular \t: <title>(.*?)</title>");  
               System.out.println("Match! \t\t\t: "+mat.group(1));  
           }  
       }  
}  

tar cvf archivo.tar 

tar xvf archivo.tar

tar tvf archivo.tar

tar czvf archivo.tar.gz

tar xzvf archivo.tar.gz

tar tzvf archivo.tar.gz

gzip -q archivo

gzip -d archivo.gz

bzip2 archivo

bunzip2 archivo

bzip2 -d archivo.bz2

bunzip2 archivo.bz2

tar -c archivos | bzip2 > archivo.tar.bz2

bzip2 -dc archivo.tar.bz2 | tar -xv

tar jvxf archivo.tar.bz2 (versiones recientes de tar)

bzip2 -dc archivo.tar.bz2 | tar -tv

zip archivo.zip 

unzip archivo.zip

unzip -v archivo.zip

lha archivo.lha 

lha -x archivo.lha

lha -v archivo.lha

lha -l archivo.lha

zoo -a archivo.zoo 

zoo -x archivo.zoo

zoo -v archivo.zoo

zoo -L archivo.zoo

rar -a archivo.rar 

rar -x archivo.rar

rar -v archivo.rar

rar -l archivo.rar

#include <stdio.h>  //std I/O
#include <string.h>   //manejo de strings 
#include <stdlib.h>   //malloc 
#include <netdb.h>  //gethostbyname, structs, recv,send, ...
#include <unistd.h>  //close


#define PORT 80
#define BUFSIZE 1024

int main(int argc, char *argv[])
{
int mi_socket;
struct sockaddr_in *con;
struct hostent *he;
char buffer[BUFSIZE];
char peticion[100];
int i;

if (argc != 3)
{
  fprintf(stderr,"Parametros incorrectos:\nModo de uso: %s <host> <path>\n",argv[0]);
 fprintf(stderr,"Ejemplo    : %s www.web.com index.php\n",argv[0]);
  exit(1);
}
sprintf(peticion,"GET /%s/ HTTP/1.0\r\nHost:%s\r\nUser-agent:Mozilla 5.0 Compatible\r\n\r\n",argv[2],argv[1]);

fprintf(stdout,"#===========#Request:#============#\n");
fprintf(stdout,"%s\n",peticion);
fprintf(stdout,"#=================================#\n");
mi_socket=socket(AF_INET,SOCK_STREAM,0);

if(mi_socket==-1)
{
 fprintf(stderr,"->Error al crear el socket\n");
 exit(1);
}
fprintf(stdout,"->Socket creado\n");
if ((he=gethostbyname(argv[1])) == NULL)
{
       fprintf(stderr,"->Error al obtener informacion de la maquina\n");    
       exit(1);
}
con = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
con->sin_family = AF_INET;
con->sin_port = htons(PORT);
con->sin_addr = *((struct in_addr *)he->h_addr);
memset(con->sin_zero,0,8);

if (connect(mi_socket, (struct sockaddr *)con,sizeof(struct sockaddr)) == -1)
{
       fprintf(stderr,"->Error al conectar\n");
       exit(1);
}
fprintf(stdout,"->Socket conectado\n");
send(mi_socket, peticion, strlen(peticion), 0);
fprintf(stdout,"->Peticion enviada\n");
fprintf(stdout,"->Recibiendo respuesta...\n\n");
memset(buffer, 0, sizeof(buffer));
while((i=recv(mi_socket, buffer, BUFSIZE, 0))>0)
{
   fprintf(stdout,"%s",buffer);
   memset(buffer, 0, i); //seteo lo que use del buffer en 0
}
//free(con);     
close(mi_socket);
fprintf(stdout,"->Conexion cerrada\n");
return 0;
}

CREATE DATABASE prueba;

USE prueba;

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


// cadenas referenciadoras para el mensaje original y cifrado
char *alfabeto="abcdefghijklmnñopqrstuvwxyz";
char *cifrado ="DEFGHIJKLMNÑOPQRSTUVWXYZABC";

//Prototipo de funciones para cifrar y decibrar el texto
char* cifra(char*);
char* descifra(char*);

//Funcion principal para probar el uso de las funciones
int main(void)
{
  char cadena[300];
  char *res;
  fprintf(stdout,"Ingrese texto a cifrar\t:\n");
  fscanf(stdin,"%s",cadena);
  res=cifra(cadena);
  fprintf(stdout,"\nLa cadena Cifrada es\t:%s\n\n",res);
  res=descifra(res);
  fprintf(stdout,"La cadena Desifrada es\t:%s",res);
  getchar();
  getchar();
  return 0;
}

//Funcion que cifra el mensaje
char* cifra(char *text)
{
    int i,j;
    for(j=0;j<strlen(text);j++)
    {
      for(i=0;i<strlen(alfabeto);i++)
      {
         if(*(text+j)==*(alfabeto+i))
         {
         *(text+j)=*(cifrado+i); 
         }
      }
    }
    return text;
}

//Funcion que descifra el mensaje
char* descifra(char *text)
{
    int i,j;
    for(j=0;j<strlen(text);j++)
    {
      for(i=0;i<strlen(alfabeto);i++)
      {
         if((*(text+j))==*(cifrado+i))
         {
         *(text+j)=*(alfabeto+i); 
         }
      }
    }
    return text;
}

/**********************************************
* Nombre        : garbo.c
* Author        : S[e]C
* Date          : 30-06-09 
* Description   : Code/Decode Cifrado Garbo
***********************************************/

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

/*
 * Alfabeto original y los 5 alfabetos de cifrado
 */

char alfabeto[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 
char alf1[]    ="GHIJKLMNOPQRSTUVWXYZABCDEFghijklmnopqrstuvwxyzabcdef";
char alf2[]    ="EFGHIJKLMABCDNOPQRSTZUVWXYefghijklmabcdnopqrstzuvwxy";
char alf3[]    ="AZYBXCWDVEFUTGHSRIJQKPLMONazybxcwdvefutghsrijqkplmon";
char alf4[]    ="QRSTUVWXYZBACEDFHGJILKMONPqrstuvwxyzbacedfhgjilkmonp";
char alf5[]    ="DEGFIHJABCKOLMNPRQTSVUZXYWdegfihjabckolmnprqtsvuzxyw";

//Prototipo funciones cifrado y descifrado
void cifra(char *text);
void descifra(char *text);

int main(void)
{
    char cad[50];
    fprintf(stdout,"Cadena a cifrar\t:");
    fscanf(stdin,"%s",cad);
    cifra(cad);    //primera pasada
    cifra(cad);    //segunda pasada
    printf("Cadena codificada\t:%s\n",cad); 
    descifra(cad); //revierte primera pasada
    descifra(cad); //revierte segunda pasada
    printf("\nCadena decodificada\t:%s\n",cad);
    setbuf(stdin,NULL);
    getchar();
    return 0;
}

void cifra(char *text)
{
     int i,k,modulo;
     for(i=0;*(text+i)!='\0';i++)
     {
       modulo=(i+1)%5; /* Obtengo el modulo de la posicion+1  ya que se considera desde
                          la letra Nº 1 de la cadena, no la posicion numero 0 de ella. */
          switch(modulo)
          {
                        
           case 0: //si el modulo es 0 uso el alfabeto 5
                for(k=0;*(alfabeto+k)!='\0';k++) //miro cada letra del alfabeto 
                { 
                   if(*(text+i)==*(alfabeto+k))  //y comparo con la primera letra de la cadena 
                      {                          //si son iguales:
                        *(text+i)=*(alf5+k);     //le asigno el valor del alfabeto de cifrado correspondiente(alfX) 
                        break;                   //salgo del ciclo.
                      }
                }
                break;
                        
           case 1:  //si el modulo es 1 uso el alfabeto 1
                for(k=0;*(alfabeto+k)!='\0';k++)
                {
                   if(*(text+i)==*(alfabeto+k))
                      {
                        *(text+i)=*(alf1+k); 
                        break; 
                      }
                      
                }
                break;
           case 2:  // si el modulo es 2 uso el alfabeto 2
                for(k=0;*(alfabeto+k)!='\0';k++)
                {
                   if(*(text+i)==*(alfabeto+k))
                      {
                        *(text+i)=*(alf2+k);
                        break;   
                      }
                       
                }
                break;
           case 3: // si el modulo es 3 uso el alfabeto 3
                for(k=0;*(alfabeto+k)!='\0';k++)
                {
                   if(*(text+i)==*(alfabeto+k))
                      {
                        *(text+i)=*(alf3+k); 
                        break;
                      }
                       
                }
                break;
           case 4: // si el modulo es 4 uso el alfabeto 4
                for(k=0;*(alfabeto+k)!='\0';k++)  
                {
                   if(*(text+i)==*(alfabeto+k))
                      {
                        *(text+i)=*(alf4+k);  
                        break;
                      }
                }
                break;
           default: // si el modulo es 4 uso el alfabeto 4
                for(k=0;*(alfabeto+k)!='\0';k++)  
                {
                   if(*(text+i)==*(alfabeto+k))
                      {
                        *(text+i)=*(alf5+k);  
                        break;
                      }
                }
          }
     }
}

void descifra(char *text)
{
     int i,k,modulo;
     for(i=0;*(text+i)!='\0';i++)
     {
       modulo=(i+1)%5;  //Obtengo el modulo, IDEM que en el proceso de cifrado
          switch(modulo)
          {
           case 0: //si el modulo es 0 decodifico la letra buscando en el alfabeto 5
                for(k=0;*(alf5+k)!='\0';k++)     //miro cada letra del alfabeto X 
                {                                //( X = alfabeto correspondiente al modulo )
                   if(*(text+i)==*(alf5+k))      //comparo con la primera letra de la cadena
                      {                          //si son iguales:
                        *(text+i)=*(alfabeto+k); //Le asigno la letra correspondiente 
                        break;                   //en el alfabeto Original, y salgo del ciclo.
                      }
                }
                break;
                        
           case 1: //si el modulo es 0 decodifico la letra buscando en el alfabeto 1
                for(k=0;*(alf1+k)!='\0';k++)
                {
                   if(*(text+i)==*(alf1+k))
                      {
                        *(text+i)=*(alfabeto+k); 
                        break; 
                      }
                      
                }
                break;
           case 2: //si el modulo es 0 decodifico la letra buscando en el alfabeto 2
                for(k=0;*(alf2+k)!='\0';k++)
                {
                   if(*(text+i)==*(alf2+k))
                      {
                        *(text+i)=*(alfabeto+k);
                        break;   
                      }
                       
                }
                break;
           case 3: //si el modulo es 0 decodifico la letra buscando en el alfabeto 3
                for(k=0;*(alf3+k)!='\0';k++)
                {
                   if(*(text+i)==*(alf3+k))
                      {
                        *(text+i)=*(alfabeto+k); 
                        break;
                      }
                       
                }
                break;
           case 4: //si el modulo es 0 decodifico la letra buscando en el alfabeto 4
                for(k=0;*(alf4+k)!='\0';k++)
                {
                   if(*(text+i)==*(alf4+k))
                      {
                        *(text+i)=*(alfabeto+k);  
                        break;
                      }
                       
                }
          }
     }
}