Tiempo de Tux

Crear un explorador de Archivos Android

2015-02-11T17:10:00.001-06:00

Como vimos en un tutorial pasado aprendimos a buscar y encontrar todas las rutas de almacenamiento interno o sd,en este caso aprenderemos como crear un explorador de archivos partiendo de eso.

Este explorador lo haremos en partes,en este tutorial aprenderemos a crear un explorador minimo,lo suficiente para navegar por directorios y ver archivos,no los podremos abrir ni nada solo ver,pero en otros tutoriales lo mejoraremos.

Bien,si ven el tutorial de como buscar las sd cards o almacenamientos,al final podemos ver una imagen donde se muestran las rutas de los almacenamientos con texto.

http://itimetux.blogspot.mx/2015/02/como-detectar-rutas-de-almacenamiento.html

Justamente partiremos de eso,solo que usaremos diseño grafico,dicen que el diseño grafico hace que la programación se vea agradable y como no soy diseñador grafico vamos a usar iconos de:

iconspedia.com

Estos son los que yo ocupe:

http://www.iconspedia.com/icon/generic-folder-icon-27678.html

http://www.iconspedia.com/icon/file-blank-icon-47723.html

http://www.iconspedia.com/icon/explorer-icon-25475.html

http://www.iconspedia.com/icon/hdd-usb-icon-23267.html

Primero vamos a abrir eclipse y crear un nuevo proyecto android,le vamos a poner de nombre,por ejemplo:

Timeexplorer

Ahora vamos a crear un grid para elegir los posibles almacenamientos,pero para crear un grid necesitamos un Adaptador,pero primero vamos a crear un objeto donde guardar la informacion de cada archivo:

package com.itimetux.timeexplorer;

public class Archivo {
 private String Path;
 private String Name;
 private boolean isDir;
 public Archivo(String Name,String Path,boolean dir){
  this.Name = Name;
  this.Path = Path;
  this.isDir = dir;
 }
 public void setName(String Name) {
  this.Name = Name;
 }
 public void setPath(String Path){
  this.Path = Path;
 }
 public void setIsDir(boolean dir){
  this.isDir = dir;
 }
 public String getName() {
  return this.Name;
 }
 public String getPath() {
  return this.Path;
 }
 public boolean isDirectory() {
  return this.isDir;
 }
}

Ese archivo no se tiene que explicar mucho solo son getters y setters que es el objeto mínimo para guardar información,uno para el nombre otro para el path y también para ver si es un directorio,este se podría usar desde la clase File pero nos ahorramos usar mas de una llamada.

Bien ahora si el Adapter,lo explico en el codigo:

package com.itimetux.timeexplorer;

import java.util.ArrayList;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class Adapter extends ArrayAdapter<Archivo> {
 private Context c; // Contexto
 private int id; // Id del resource (layout)
 private ArrayList<Archivo> Archivos; // Todos los archivos

 public Adapter(Context context, int id, ArrayList<Archivo> archivos) {
  super(context, id, archivos);
  c = context; // Definimos las variables globales
  this.id = id;
  Archivos = archivos;
 }

 public Archivo getArchivo(int i) {
  return Archivos.get(i); // Esta funcion regresa un Archivo basado en el
        // index que le pasemos
 }

 @Override
 public View getView(int position, View convertView, ViewGroup parent) {
  View layout = convertView;
  if (layout == null) {
   LayoutInflater Linflated = (LayoutInflater) c
     .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
   layout = Linflated.inflate(id, null); // Inflamos la layout
  }

  final Archivo file = Archivos.get(position); // Guardamos el archivo
              // actual en un objeto
  if (file != null) { // Vemos si no hay un error
   TextView Name = (TextView) layout.findViewById(R.id.textViewName); // El
                    // nombre
   TextView Path = (TextView) layout.findViewById(R.id.textViewPath); // El
                    // path
                    // o
                    // ruta
   /*
    * Para el nombre y el path vemos si hay un error y si no es asi le
    * ponemos el texto
    */
   if (Name != null)
    Name.setText(file.getName());
   if (Path != null)
    Path.setText(file.getPath());
   // Vemos si es un directorio
   if (file.isDirectory()) {
    ImageView folder = (ImageView) layout
      .findViewById(R.id.imageViewIcon);
    Drawable image = c.getResources().getDrawable(
      R.drawable.generic256);
    folder.setImageDrawable(image); // Si es asi le ponemos el icono
            // de directorio
   }
   if (!file.isDirectory()) { // Si no es directorio
    ImageView folder = (ImageView) layout
      .findViewById(R.id.imageViewIcon);
    Drawable image = c.getResources().getDrawable(
      R.drawable.fileblanc256);
    folder.setImageDrawable(image); // Le ponemos el icono de
            // archivo
   }
  }
  return layout;
 }
}

Ese seria un adaptador mínimo para usar un grid,ahora lo podríamos llamar definiendo lo necesario en MainActivity y quedaría así:

Se ve mejor con iconos :D

Bien aun no lo podemos usar primero tenemos que manejar el evento de clic sobre los elementos de almacenamiento que están en el grid,en mi caso 2,asi queda el MainActivity:

package com.itimetux.timeexplorer;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.GridView;


public class MainActivity extends ActionBarActivity {
 private GridView SDS; // Grid
 private ArrayList<String> SD_CARDS; // Rutas de almacenamiento

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main); // Asignamos el layout principal
        SDS = (GridView) findViewById(R.id.sdcards); // Definimos el grid
        SD_CARDS = getAllsds();  // Definimos las rutas de almacenamiento
        final GridAdapter gadapter = new GridAdapter(this,
    R.layout.sdcards, SD_CARDS); // Creamos un adaptador
        SDS.setAdapter(gadapter); // Le asignamos el adaptador al grid
        SDS.setOnItemClickListener(new OnItemClickListener() { 
         // Manejamos los clic sobre los elementos del grid
   @Override
   public void onItemClick(AdapterView<?> a, View v,
     final int position, long id) {
    // Vamos a iniciar una nueva actividad pasando como extra la ruta de almacenamiento
    Intent in = new Intent(MainActivity.this, Explorador.class);
    in.putExtra("SD", SD_CARDS.get(position));
    startActivity(in); // Inicamos la actividad
   }
  });
    }

    private ArrayList<String> getAllsds() {
  ArrayList<String> tmp = new ArrayList<String>(); // Array de todas las rutas

  String rutas[] = { "/mnt/", "/storage/" }; // Rutas posibles

  for (int i = 0; i < rutas.length; i++) {
   File file = new File(rutas[i]);// Ruta actual ( listamos de uno a uno )
   if (!file.exists()) // Si no existe pasamos a la siguiente
    continue;
   System.out.println("Ruta : " + rutas[i]); // Imprimimos para "depurar"
   String f[] = file.list(); // Contenido de ruta actual
   for (int o = 0; o < f.length; o++) { // Recorremos el contenido de la ruta actual
    if (f[o].indexOf("sd") != -1) { // Vemos si contiene sd en el nombre si es asi es almacenamiento
     String ruta = rutas[i] + f[o]; // Creamos una Ruta,esta ruta es la original
     File fd = new File(ruta); // Creamos un nuevo File para evitar rutas repetidas basadas en symlinks
     String toAdd;
     try {
      System.out.println("Canocial :"
        + fd.getCanonicalPath().toString()); // Esta seria la ruta original
      toAdd = fd.getCanonicalPath().toString();
     } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      toAdd = null;
      continue;
     }
     if (!tmp.contains(toAdd)) { // Si se repitiera no lo añadimos
      System.out.println("A añadir :" + toAdd);
      tmp.add(toAdd);
     }
    }
   }
  }

  return tmp; // Regresamos el Array de almacenamientos
 }
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

El menú no lo tocamos,tan solo trabajamos en el onCreate,vamos a definir los .xml que hasta ahora necesitamos:

sdcards.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="200dp"
    android:layout_height="200dp"
    android:orientation="horizontal" >

    <ImageView
        android:id="@+id/tarjeta"
        android:layout_width="100dp"
        android:layout_height="100sp"
        android:gravity="center"
        android:src="@drawable/hddusb256" />

    <TextView
        android:id="@+id/nombretarjeta"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textColor="#000"
        android:textStyle="bold"
        />

</LinearLayout>

El activity_main.xml:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.itimetux.timeexplorer.MainActivity" >

    <GridView
        android:id="@+id/sdcards"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:numColumns="auto_fit"
        android:stretchMode="columnWidth" >
    </GridView>

</RelativeLayout>

Solo falta crear el explorador,para ello definiremos una activitad que se extienda de ListActivity y a la cual es la que llamamos cuando le damos clic a una ruta de almacenamiento:

package com.itimetux.timeexplorer;

import java.io.File;
import java.util.ArrayList;

import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.ListView;
import android.widget.Toast;

public class Explorador extends ListActivity {
 private Adapter adapter;
 private File FullDir;
 private String SDCARD_PATH = "";

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  Intent intent = getIntent();
  Bundle extras = intent.getExtras(); // Llamamos los extras
  SDCARD_PATH = extras.getString("SD"); // Llamamos la ruta de
            // almacenamiento que mandamos
            // en el main
  File Directorio = new File(SDCARD_PATH); // Creamos un objeto File con
             // la ruta de almacenamiento
  if (Directorio.exists()) { // Primero vemos si existe,por si algo
         // saliera mal
   try { // Iniciamos un try,por si algo saliera mal de nuevo
    startList(Directorio); // Mandamos la ruta inicial a la funcion
          // que creara la vista
   } catch (Exception e) {
    e.printStackTrace();
    Toast.makeText(
      getApplicationContext(),
      "No puedes acceder en este momento a " + " "
        + SDCARD_PATH, Toast.LENGTH_LONG).show(); 
    // Sino podemos acceder lo mostramos
   }
  }
 }

 private void startList(File Directorio) {
  String titulo = Directorio.getName(); // Obtenemos el nombre de la ruta actual
  this.setTitle(titulo); // Colocamos el titulo a la vista
  FullDir = Directorio; // Asignamos esta variable extra que usaremos despues

  File Allfiles[] = Directorio.listFiles(); // Listamos todos los archivos del directorio actual
  if (Directorio.listFiles() == null) { // Si es null,esta vacio y lo mostramos
   Toast.makeText(getApplicationContext(), "Carpeta vacia",
     Toast.LENGTH_SHORT).show();
   return;
  }
  // Creamos un Array para los directorios
  ArrayList<File> Dirs = new ArrayList<File>();
  // Creamos un Array para los archivos
  ArrayList<File> Files = new ArrayList<File>();
  //Creamos un array para guardar Archivos y Directorios
  //Esto servira para ordenarlos
  ArrayList<File> AllFilesGood = new ArrayList<File>();
  // Creamos un Array de Archivos que guardara la informacion de archivos y directorios
  ArrayList<Archivo> Archivos = new ArrayList<Archivo>();
  for (int i = 0; i < Allfiles.length; i++) { // Recorremos la ruta actual
    // Si es .android_secure no la usamos ya que no nos deja Android
   if (Allfiles[i].getName().equals(".android_secure"))
    continue;
   // Si es un directorio lo ponemos en Dirs
   if (Allfiles[i].isDirectory()) {
    Dirs.add(Allfiles[i]);
   // Si es un Archivo lo ponemos en Files
   } else if (Allfiles[i].isFile()) {
    Files.add(Allfiles[i]);
   } else {
    // Si no es directorio ni archivo 
    // Continuamos(podemos omitir esta linea de codigo)
    continue; 
   }
  }
  // Podemos poner directorios y luego archivos,o viceversa
  AllFilesGood.addAll(Dirs); // Ponemos directorios primero
  AllFilesGood.addAll(Files); // Pondemos Archivos despues
  // Vemos si es la raiz(la ruta del almacenamiento)
  if (!Directorio.getAbsolutePath().equals(SDCARD_PATH)) 
   Archivos.add(new Archivo("...", "", true)); // Si no es la raiz agregamos una forma de regresar
  for (int i = 0; i < AllFilesGood.size(); i++) { // Recorremos Todos los archivos
   File tmp = AllFilesGood.get(i); // Creamos un objeto que se destruira muy rapidamente
   boolean flag = false; // Usamos esta variable para ver si es un directorio
   if (tmp.isDirectory()) // Vemos is es un directorio
    flag = true;
   Archivos.add(new Archivo(tmp.getName(), tmp.getPath(), flag)); // Agregamos un nuevo objeto
  }
  // Asignamos al adaptador el context,el layout y un array de archivos
  adapter = new Adapter(Explorador.this, R.layout.explorer, Archivos);
  this.setListAdapter(adapter); // Asignamos el adaptador
 }

 @Override
 protected void onListItemClick(ListView l, View v, int position, long id) {
  // Manejamos los clic
  super.onListItemClick(l, v, position, id);
  Archivo archivo = adapter.getArchivo(position); // Creamos un archivo temporal
  if (archivo.isDirectory()) { // Vemos si es directorio
   if (archivo.getName().equals("...")) { // Si es el regreso regresamos al path anterior
    // Con estas lineas de codigo obtenemos el path anterior
    String[] segments = FullDir.getAbsolutePath().split("/");
    String lastPath = "";
    for (int i = 1; i < segments.length; i++) {
     if (i != segments.length - 1) {
      lastPath = lastPath + "/" + segments[i];
     }
    }
    startList(new File(lastPath)); // Recargamos la vista
    return;
   }
   File Directorio = new File(archivo.getPath()); // Obtenemos el path
   startList(Directorio); // Recargamos la vista
  }
  // Aqui manejariamos los archivos
 }

}

También necesita de un xml llamado explorer.xml:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >

    <ImageView
        android:id="@+id/imageViewIcon"
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:layout_marginTop="10dp"
        android:maxHeight="5dp"
        android:maxWidth="5dp"
        android:src="@drawable/generic256" />

    <TextView
        android:id="@+id/textViewName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignTop="@+id/imageViewIcon"
        android:layout_toRightOf="@+id/imageViewIcon"
        android:lines="1"
        android:textStyle="bold" />

    <TextView
        android:id="@+id/textViewPath"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignBottom="@+id/imageViewIcon"
        android:layout_alignLeft="@+id/textViewName"
        android:lines="1" />

</RelativeLayout>

Por ultimo necesitamos Modificar el Manifiest,necesitamos añadir el Activity de exploración y añadir el permiso de leer la memoria:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.itimetux.timeexplorer"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
         <activity
            android:name=".Explorador"
            android:label="@string/app_name" >
        </activity>
    </application>

</manifest>

También para que funcione necesitamos tener soporte para ActionBarActivity v7,esto es largo de explicar en este tutorial así que pueden pedir ayuda en google.

Y listo asi queda:

Eso es todo :D

Como leer Numeros Magicos con C (file signatures)

2015-02-11T13:44:00.000-06:00

En esta ocasión aprenderemos a leer los números mágicos de un archivo,esto funciona para saber el tipo de archivo de un archivo,si así como suena ya que algunas ocasiones podemos deducir el tipo de archivo solo por su extension,por ejemplo podemos tener una imagen con este nombre:

imagen.png

Pero que tal si es formato .jpg o incluso un vídeo o audio,esto no es muy importante,para el usuario,pero a la hora de programar algo de bajo nivel o incluso de nivel usuario,por ejemplo una GUI si no seleccionamos el archivo correcto tendríamos un error,por ejemplo un reproductor de música o vídeo que le mandemos una imagen como ruta,esto causaría el cierre de la aplicación o en sistemas débiles el congelamiento de todo el sistema.

Bueno también en ocasiones tenemos archivos sin extensión,con el nombre por ejemplo:

archivo

En Unix si tiene permisos de ejecución lo mas seguro es que sea un programa,pero en ocasiones son archivos multimedia,como dije el usuario no se debe preocupar por esto ya que si tienen un explorador potente como por ejemplo Dolphin de KDE el lee los Magic Numbers y si tenemos una imagen sin extensión la detecta:

Como vemos detecta los archivos,pero si quisiéramos crear un explorador necesitaríamos usar números mágicos y no filtro por extensión.

En esta ocasión vamos a hacer este trabajo usando C,ya que lo vamos a usar en el sistema,si lo quisiéramos usar por ejemplo en Android lo podemos hacer en Java o usando el NDK.

Bien vamos a leer el archivo en modo binario y vamos a leer los primeros 8 bytes que serian 8 char,los primeros 8 char del archivo,luego los vamos a imprimir en pantalla,hay caracteres Hex que no se pueden imprimir asi que solo imprimiremos los que se puedan.

#include <stdio.h>
#include <ctype.h>

#define BYTES 8 // Numero de bytes

void readFile(char *file); // Funcion que leera el archivo,le pasamos el nombre

int main(int argv,char *argc[])
{
    if (argv>1)
        readFile(argc[1]); // Le pasamos el nombre del archivo que indiquemos en el argumento
    return 0;
}

void readFile(char *file)
{
    char nums[BYTES]; // Definimos un array de n bytes
    int i;
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo en modo binario y lectura
    fread(nums,1,BYTES,fp); // Lemos los primeros n bytes
    for (i=0;i<BYTES;i++) // Recorremos el array
    {
        if (isgraph(nums[i]))  // Si se puede imprimir
            printf("Nums %c\n",nums[i]); // Lo imprimimos
    }

    fclose(fp);
    return;
}

Ahora vamos a usarlo:

Como vemos en el primer archivo use una imagen png con extensión jpg y no hubo problema al detectar el tipo de archivo,en el segundo use un .pdf y efectivamente es .pdf.

Algunos archivos no simplemente van a decir PNG o PDF,por ejemplo el numero magico de un mp3 es ID3:

Algunos números mágicos los podemos encontrar aquí:

https://en.wikipedia.org/wiki/List_of_file_signatures

Y eso nos sirve para definir un array de comprobacion,por ejemplo para el mp3,seria en HEX:

49 44 33

Que solo serian 3 bytes,3 char:

Veamos:

#include <stdio.h>
#include <ctype.h>

#define BYTES 8 // Numero de bytes

typedef enum _boolean {FALSE,TRUE} boolean; // Tipo boolean

void readFile(char *file); // Funcion que leera el archivo,le pasamos el nombre

boolean isMp3(char *file); // Funcion para saber si es mp3

int main(int argv,char *argc[])
{
    if (argv>1){

        readFile(argc[1]); // Le pasamos el nombre del archivo que indiquemos en el argumento
        if(isMp3(argc[1])) // Vemos si es mp3
            printf("%s es mp3\n",argc[1]);
        else
            printf("%s no es mp3\n",argc[1]);
    }
    
    return 0;
}

boolean isMp3(char *file)
{
    const int lenNum = 3; // Numero de Bytes
    char nums[lenNum]; // array que contendra los numero magicos
    char id[] = {0x49,0x44,0x33}; // Numeros magicos del mp3
    int i;
    boolean flag = TRUE; // Este sera el valor de retorno
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo
    fread(nums,1,lenNum,fp); // Lemos los primeros 3 bytes
    for (i=0;i<lenNum;i++) // Recorremos el array
    {
        if(nums[i] != id[i]) // Si no son iguales 
        {
             flag = FALSE; // Cambiamos el valor de retorno
             break; // rompemos el bucle
        }
    }
    fclose(fp); // Cerramos el archivo
    return flag; // Regresamos el valor
}

void readFile(char *file)
{
    char nums[BYTES]; // Definimos un array de n bytes
    int i;
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo en modo binario y lectura
    fread(nums,1,BYTES,fp); // Lemos los primeros n bytes
    for (i=0;i<BYTES;i++) // Recorremos el array
    {
        if (isgraph(nums[i]))  // Si se puede imprimir
            printf("Nums %c\n",nums[i]); // Lo imprimimos
    }

    fclose(fp);
    return;
}

Con esa funcion que definimos logramos saber si un archivo es mp3,igual lo podemos hacer con un mp4 solo que wikipedia nos dice que hay dos posibilidades,veamos:

#include <stdio.h>
#include <ctype.h>

#define BYTES 8 // Numero de bytes

typedef enum _boolean {FALSE,TRUE} boolean; // Tipo boolean

void readFile(char *file); // Funcion que leera el archivo,le pasamos el nombre

boolean isMp3(char *file); // Funcion para saber si es mp3

boolean isMp4(char *file);

int main(int argv,char *argc[])
{
    if (argv>1){

        readFile(argc[1]); // Le pasamos el nombre del archivo que indiquemos en el argumento
        if(isMp4(argc[1])) // Vemos si es mp3
            printf("%s es mp4\n",argc[1]);
        else
            printf("%s no es mp4\n",argc[1]);
    }
    
    return 0;
}

boolean isMp4(char *file)
{
    const int lenNum = 4; // Numero de Bytes
    char nums[lenNum]; // array que contendra los numero magicos
    char id1[] = {0x22,0x67,0x70,0x35}; // Numeros magicos del mp4
    char id2[] = {0x66,0x74,0x79,0x70}; // Numeros magicos del mp4(otra posibilidad)
    int i;
    boolean flag = TRUE; // Este sera el valor de retorno
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo
    fread(nums,1,lenNum,fp); // Lemos los primeros 4 bytes para probar el primer id
    for (i=0;i<lenNum;i++) // Recorremos el array
    {
        if(nums[i] != id1[i]) // Si no son iguales 
        {
             flag = FALSE; // Cambiamos el valor de retorno
             break; // rompemos el bucle
        }
    }
    if (flag == FALSE) // Si la bandera es FALSE probamos el siguiente id
    {
        flag = TRUE; // Cambiamos el flag a TRUE
        fseek( fp, 4, SEEK_SET ); // Nos movemos 4 bytes a la derecha ya que no nos sirven estos : 00 00 00 nn
        fread(nums,1,lenNum,fp); // Lemos los segundos 4 bytes
        for (i=0;i<lenNum;i++) // Recorremos el array
        {
            if(nums[i] != id2[i]) // Si no son iguales 
            {
                flag = FALSE; // Cambiamos el valor de retorno
                break; // rompemos el bucle
            }
        }
    }
    fclose(fp); // Cerramos el archivo
    return flag; // Regresamos el valor
}

boolean isMp3(char *file)
{
    const int lenNum = 3; // Numero de Bytes
    char nums[lenNum]; // array que contendra los numero magicos
    char id[] = {0x49,0x44,0x33}; // Numeros magicos del mp3
    int i;
    boolean flag = TRUE; // Este sera el valor de retorno
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo
    fread(nums,1,lenNum,fp); // Lemos los primeros 3 bytes
    for (i=0;i<lenNum;i++) // Recorremos el array
    {
        if(nums[i] != id[i]) // Si no son iguales 
        {
             flag = FALSE; // Cambiamos el valor de retorno
             break; // rompemos el bucle
        }
    }
    fclose(fp); // Cerramos el archivo
    return flag; // Regresamos el valor
}

void readFile(char *file)
{
    char nums[BYTES]; // Definimos un array de n bytes
    int i;
    FILE *fp = fopen(file,"rb"); // Abrimos el archivo en modo binario y lectura
    fread(nums,1,BYTES,fp); // Lemos los primeros n bytes
    for (i=0;i<BYTES;i++) // Recorremos el array
    {
        if (isgraph(nums[i]))  // Si se puede imprimir
            printf("Nums %c\n",nums[i]); // Lo imprimimos
    }

    fclose(fp);
    return;
}

Así podemos crear un biblioteca con todas las extensiones para usarlas en un programa.

Eso es todo :D

Como detectar rutas de almacenamiento en Android

2015-02-08T13:52:00.000-06:00

En esta entrada vamos a aprender a detectar rutas de almacenamiento en Android,esto puede que se entienda para diversas cosas, a lo que me refiero es encontrar los puntos de montaje de nuestras tarjetas sd o de la memoria interna,ya que muchos dispositivos sean tablets,smartphones tienen rutas distintas,por ejemplo:

/mnt/sdcard

otras

/mnt/sdcard0

etc.

Con la funcion de Environment esta:

Environment.getExternalStorageDirectory();

Nos da solo la externa pero para los dispositivos con mas de una memoria esto se complica.

Esta función no nos da la ruta interna:

Environment.getDataDirectory();

Nos da la ruta data de la aplicación,algo así como:

/data

Y no es lo que queremos en este caso,en este caso es por ejemplo para una aplicaccion multimedia que busca todos los archivos de música,fotos o vídeo y para eso necesitamos los distintos almacenamientos.

Para hacer lo que mencione existe la MediaStore que contempla las rutas pero muchas veces no tiene información completa y se tarda en actualizar en dispositivos antiguos por ejemplo si le acabamos de mandar imagenes por medio de la pc en almacenamiento masivo,así que es mejor buscar la información nosotros mismos.

Bien,la solución que vamos a usar aquí es la siguiente,vamos a buscar en las posibles rutas de montaje de Android y guardar las carpetas que contengan sd ya que en muchos dispositivos así es como lo hace Android,si no es asi tendríamos que añadir otras coincidencias.

Primero que nada vamos a crear un ArrayList de Strings que va a guardar las rutas sd:

private ArrayList SD_CARDS;

Ahora vamos a crear una función que haga el trabajo:

 private ArrayList<String> getAllsds() {
  ArrayList<String> tmp = new ArrayList<String>(); // Array de todas las rutas

  String rutas[] = { "/mnt/", "/storage/" }; // Rutas posibles

  for (int i = 0; i < rutas.length; i++) {
   File file = new File(rutas[i]);// Ruta actual ( listamos de uno a uno )
   if (!file.exists()) // Si no existe pasamos a la siguiente
    continue;
   System.out.println("Ruta : " + rutas[i]); // Imprimimos para "depurar"
   String f[] = file.list(); // Contenido de ruta actual
   for (int o = 0; o < f.length; o++) { // Recorremos el contenido de la ruta actual
    if (f[o].indexOf("sd") != -1) { // Vemos si contiene sd en el nombre si es asi es almacenamiento
     String ruta = rutas[i] + f[o]; // Creamos una Ruta,esta ruta es la original
     File fd = new File(ruta); // Creamos un nuevo File para evitar rutas repetidas basadas en symlinks
     String toAdd;
     try {
      System.out.println("Canocial :"
        + fd.getCanonicalPath().toString()); // Esta seria la ruta original
      toAdd = fd.getCanonicalPath().toString();
     } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      toAdd = null;
      continue;
     }
     if (!tmp.contains(toAdd)) { // Si se repitiera no lo añadimos
      System.out.println("A añadir :" + toAdd);
      tmp.add(toAdd);
     }
    }
   }
  }

  return tmp; // Regresamos el Array de almacenamientos
 }

Ahora solo debemos llamar la función:

SD_CARDS = getAllsds();

Y listo :D

Las rutas se ven el el Logcat pero vamos a mostrarlo en la aplicación mínima que nos crea Eclipse o Android Studio:

Supongamos que el paquete se llama:

com.itimetux.alamacenamientos

Así debe quedar el MainActivity:

package com.itimetux.alamacenamientos;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class MainActivity extends ActionBarActivity {
 private ArrayList<String> SD_CARDS;
 private TextView rutas;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  rutas = (TextView) findViewById(R.id.textView1);
  SD_CARDS = getAllsds();
  String sd = "";
  for (int i=0;i<SD_CARDS.size();i++)
  {
   sd += SD_CARDS.get(i);
   sd += "\n";
  }
  rutas.setText(sd);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
  // Inflate the menu; this adds items to the action bar if it is present.
  getMenuInflater().inflate(R.menu.main, menu);
  return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
  // Handle action bar item clicks here. The action bar will
  // automatically handle clicks on the Home/Up button, so long
  // as you specify a parent activity in AndroidManifest.xml.
  int id = item.getItemId();
  if (id == R.id.action_settings) {
   return true;
  }
  return super.onOptionsItemSelected(item);
 }

 private ArrayList<String> getAllsds() {
  ArrayList<String> tmp = new ArrayList<String>(); // Array de todas las rutas

  String rutas[] = { "/mnt/", "/storage/" }; // Rutas posibles

  for (int i = 0; i < rutas.length; i++) {
   File file = new File(rutas[i]);// Ruta actual ( listamos de uno a uno )
   if (!file.exists()) // Si no existe pasamos a la siguiente
    continue;
   System.out.println("Ruta : " + rutas[i]); // Imprimimos para "depurar"
   String f[] = file.list(); // Contenido de ruta actual
   for (int o = 0; o < f.length; o++) { // Recorremos el contenido de la ruta actual
    if (f[o].indexOf("sd") != -1) { // Vemos si contiene sd en el nombre si es asi es almacenamiento
     String ruta = rutas[i] + f[o]; // Creamos una Ruta,esta ruta es la original
     File fd = new File(ruta); // Creamos un nuevo File para evitar rutas repetidas basadas en symlinks
     String toAdd;
     try {
      System.out.println("Canocial :"
        + fd.getCanonicalPath().toString()); // Esta seria la ruta original
      toAdd = fd.getCanonicalPath().toString();
     } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      toAdd = null;
      continue;
     }
     if (!tmp.contains(toAdd)) { // Si se repitiera no lo añadimos
      System.out.println("A añadir :" + toAdd);
      tmp.add(toAdd);
     }
    }
   }
  }

  return tmp; // Regresamos el Array de almacenamientos
 }
}

Así queda la vista xml activity_main.xmll:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.itimetux.alamacenamientos.MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/textView1"
        android:text="@string/hello_world" />

</RelativeLayout>

Y por ultimo el AndroidManifiest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.itimetux.alamacenamientos"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Ejecutamos:

En otro dispositivo:

Para que funcione el MainActivity tal y como lo coloque aquí necesitan tener instalado el soporte para v7 ActionBarActivity.

Aun asi pueden probar la función getAllsds() independientemente de como sea su aplicacion,solo que necesitan añadir el permiso de acceder al almacenamiento en el AndroidManifiest.xml.

Si existen mas rutas en el futuro o alguna que no contemple tenemos que añadir la ruta aquí:

String rutas[] = { "/mnt/", "/storage/","otra_ruta" };

Si existen almacenamientos que ademas de usar el nombre sd usan otro nombre tendríamos que añadir un or así:

if (f[o].indexOf("sd") != -1 || f[o].indexOf("otra_coincidencia") != -1) { ... }

Eso es todo :D.

Como convertir un string a binario con C

2015-01-16T14:09:00.000-06:00

Esto es especificamente con C o C++,pero especificamente con C,en este caso hacemos uso del poderoso Union y de punteros:

#include <stdio.h>

typedef struct _byte { /* Estructuramos 8 bits para un Byte */
    unsigned a: 1;
    unsigned b: 1;
    unsigned c: 1;
    unsigned d: 1;
    unsigned e: 1;
    unsigned f: 1;
    unsigned g: 1;
    unsigned h: 1;
} byte;

typedef union _charbits { /* Unimos un char(caracter) con un Byte */
    char ch;
    byte bits;
} charbits;

void decode(byte b)/* Esta funcion decodifica el char en 8 bits */
{
    printf("%2u%2u%2u%2u%2u%2u%2u%2u  ",b.h,b.g,b.f,b.e,b.d,b.c,b.b,b.a);
}

void readString(const char *str)/* Esta funcion simplemente lee la string como un array de punteros a char y los decodifica char a char con la funcion de arriba*/
{
    charbits word;
    while(*str) 
    {
        word.ch = *str;
        decode(word.bits);
        *str++;
    }
    printf("\n");
}

int main(int argv,char **argc) /* Iniciamos el main */
{
    if (argv > 1)
        readString(argc[1]);
    else
        printf( "Uso : %s <Palabra>",argc[0]);
    return 0;
}

Para compilar metemos el codigo en un archivo por ejemplo:

decode.c

Y compilamos:

gcc -o decode decode.c

./decode "Tiempo de Tux"

0 1 0 1 0 1 0 0 0 1 1 0 1 0 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1 1 0 1 0 1 1 1 0 0 0 0 0 1 1 0 1 1 1 1 0 0 1 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 1 0 0 0

Eso es todo.

Como añadir ppa/repos a Ubuntu

2015-01-16T13:16:00.000-06:00

En este tutorial aprenderemos a añadir repositorios a ubuntu los conocidos en ubuntu como ppa,esto para instalar programas que no se encuentran en los sources del sistema,nos llamados main,universe,etc.

Para añadir un ppa vamos a launchpad,o al paquete que quieran instalar,en este caso vamos a probar con Shutter:

https://launchpad.net/~shutter

Vamos a donde dice:

Personal package archives y PPA for:

Ahora tenemos dos opciones la manera manual y la manera sencilla,veamos ambas:

Manera manual:

Vamos a donde dice Technical details about this PPA:

Seleccionamos la versión de nuestro sistema,en mi caso 14.04:

Copiamos lo que esta en el pre,en este caso:

deb http://ppa.launchpad.net/shutter/ppa/ubuntu trusty main

deb-src http://ppa.launchpad.net/shutter/ppa/ubuntu trusty main

Y ahora lo añadimos al sources.list de nuestro sistema:

Para ello abrimos una terminal la buscamos en el menu de programas o tecleamos ctrl+alt+t:

Ahora escribimos:

sudo nombre_de_nuestro_editor_de_texto /etc/apt/sources.list

Por ejemplo:

sudo nano /etc/apt/sources.list

Y añadimos las lineas al archivo,podemos añadir un comentario comenzando la linea con un hash:

Ahora solo guardamos,en este caso:

ctrl+o

ctrl+x

Por ultimo actualizamos las fuentes,pero primero tenemos que añadir las llaves de confianza:

En la pagina vamos abajo de donde estaban los deb,hay algo que dice:

Signing key:

Copiamos el segundo numero ya que esta dividido asi:

numero1/numero2

Copiamos el mas largo y escribimos:

gpg --keyserver keyserver.ubuntu.com --recv-keys numero2

gpg --export --armor numero2 | sudo apt-key add -

Ahora si actualizamos:

sudo apt-get update

Y el paquete ya esta listo para se instalado,solo lo buscamos como paquete,con el comando:

apt-cache search paquete

O vemos en la paguina ppa donde dice:

Overview of published packages

Filtrando los resultados para nuestra versión de ubuntu:

Eso es todo para instalar usamos(en este caso shutter):

sudo apt-get install shutter

Como ven no es método rápido,para lo que recomiendo usar este método es solo para ver si el paquete esta disponible para nuestra versión ya que si no es así podemos detener conflictos en los paquetes,o no se instalara simplemente.

Manera automatica o rapida:

Para hacer el mismo procedimiento pero de manera rapida tenemos que añadir la ppa directamente con un comando linux especial para esto.

Primero vamos a la pagina del ppa y a donde dice:

Adding this PPA to your system

Esta un texto en negrita,en este caso como ejemplo usaremos shutter:

ppa:shutter/ppa

Ahora abrimos una terminal,la buscamos en menú de aplicaciones,y escribimos:

sudo add-apt-repository ppa

En este caso:

sudo add-apt-repository ppa:shutter/ppa

Presionamos enter y actualizamos los repos:

sudo apt-get update

Y listo solo necesitamos buscar el paquete e instalarlo,en este caso:

sudo apt-cache search Shutter

sudo apt-get install shutter

Eso es todo.

Como añadir programas al menu de GNU/Linux

2015-01-13T13:38:00.000-06:00

Esta entrada va para todos entornos gráficos que son usadas en sus distribuciones,Ubuntu,Gentoo,Arch,Debian,etc.

Cuando instalamos un programa por el administrador de paquetes,ya sea yum,apt,emerge,pacman y nos instala un programa,este se añade al menu de inicio o menu de programas de nuestro entorno gráfico,(no es lo mismo a que aparezca en la terminal de manera autocompletado,al presionar tab),lo que pasa con los programas(mas que nada los que tienen interfaz grafica),es que al instalar se añade un .desktop donde viene la configuración que usara el icono que aparecerá en el menu.

En esta ocasión aprenderemos a crear o mejor dicho a añadir un programa al menu de usuario,esto es útil cuando descargamos un programa de Internet que no tiene este archivo y queremos acceder a el,también es útil por si programamos algo y queremos que se pueda acceder desde el menu, o por si queremos añadir un menu a aquellos programas que no tienen interfaz como se ve en distribuciones como Kali que usan iconos en el menu para abrir programas que solo usan stdout(terminal mínima).

Se pueden crear accesos en entornos como kde de manera sencilla pero ese no es propósito de este tutorial,el proposito es saber crear archivos .desktop:

1.Primero debemos saber que estos archivos se guardan en esta ruta:

/usr/share/applications

Así que vamos a esa ruta con cd desde una terminal:

En terminal:

cd /usr/share/applications

Ahora vamos a crear un archivo que abrirá netstat,desde un icono en el menu en mi caso uso KDE:

Creamos un archivo llamado netstatejemplo.desktop

En terminal:

sudo nano netstatejemplo.desktop

Ahora vamos a conocer la estructura de los archivos .desktop:

Los comentarios comienzan con un hash # igual que en bash.

En segundo lugar debemos añadir un groupname,el cual va encerrado en corchetes,en el uso mas frecuente y en este tutorial se debe usar Desktop Entry.

Y por ultimo saber que el archivo este codificado en UTF-8.

Ahora vamos a crear el archivo,el archivo se compone de lineas de configuración clave,valor como variables,las mas comunes para crear un archivo mínimo son:

Name : El nombre de la aplicación como aparecerá en el menu.
Type : El tipo de entrada,en este caso Application , tambien existe Directory y Link
Exec : El ejecutable,ruta absoluta.
Terminal : Valor booleano false o true para saber si se ejecutara en terminal
Icon : El icono mostrado en el menu,ruta absoluta.
NoDisplay: No mostrar,un booleano para ocultar la aplicacion aunque exista.
Categories: Sub menus donde se añadira,por ejemplo desarrollo,multimedia.
Comment : Es el tooltip que aparece en el icono(Texto al pasar el puntero sobre el icono,por ejemplo una descripción).

Tambien existen:

GenericName,Version,Hidden,OnlyShowIn,NotShowIn,DBusActivatable,TryExec,Path.

De hecho solo son necesarios dos variables,pero en nuestro ejemplo y regularmente en la mayoría de los casos solo se necesitan los mencionados primero.

Asi nos queda nuestro lanzador de netstat:

[Desktop Entry]
Name=Netstat
Type=Application
# Buscar ejecutable con which netstat
Exec=/bin/netstat
Terminal=true
NoDisplay=false
Categories=Network
Comment=Muestra conexiones de red, tablas de encaminamiento, estadísticas de interfaces, conexiones enmascaradas y mensajes del tipo netlink.

Guardamos : ctrl+o

Salimos :ctrl+x

Y instalamos,con este comando nos dirá si hay algún error:

sudo desktop-file-install /usr/share/applications/netstatejemplo.desktop

Si lo hacemos de esa manera lo abrira pero despues lo cerrara debemos cambiar el exec por:

Exec=bash -c "/bin/netstat;read"

Cerramos con enter.

Categorías de menu : http://standards.freedesktop.org/menu-spec/menu-spec-1.0.html

Referencia y mas información : http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s02.html

Como instalar Android Studio en Ubuntu

2015-01-12T13:40:00.000-06:00

Android Studio sigue avanzando y lo mas seguro es que remplace a eclipse y su plugin para el desarrollo android,yo en lo personal me gusta mas eclipse(por la costumbre),pero aun así es buena practica probar las distintas manera de desarrollar en este caso para Android,así que vamos a instalarlo en Ubuntu,en mi caso la version 14.04.

Primero arbrimos una terminal:

ctrl + Alt + T

Ahora añadimos el ppa de Android Studio:

sudo add-apt-repository ppa:paolorotolo/android-studio

Actualizamos los repos:

sudo apt-get update

Y finalmente instalamos:

sudo apt-get install android-studio

Este paquete es un poco extraño ya que no es android studio en si,sino que es un instalador,un pequeño script que instala el paquete original guardado en,por ejemplo:

https://dl.google.com/dl/android/studio/ide-zips/1.0.1/android-studio-ide-$VERSION-linux.zip

Lo descarga con wget,lo mueve a /opt y crea lo necesario para que se muestre en el menu de aplicaciones y el sistema.

Cuando termine lo podremos ejecutar:

Eso es todo.

Como actualizar Brackets Ubuntu 14.04

2015-01-12T12:42:00.000-06:00

Si revisan en donde dice Ayuda->Buscar Actualizaciones se daran cuenta que hay una nueva version,si les aparece esto es que no:

Pero si no les aparecerá otra ventana y hay que actualizar para tener lo mas nuevo que provee este editor.

Para ello vamos a la pagina de descara:

http://brackets.io/

Ahora le dan decargar,debe ser un archivo .deb.

Ahora lo que debemos hacer es abrir una terminal donde se descargo el archivo:

Abrimos la terminal:

ctrl + Alt + T

Vamos a la ruta de descarga,normalmente es Descargas tecleamos en terminal:

cd ~/Descargas

Y instalamos:

sudo dpkg -i Brackets.*

Esperamos y listo :D

Abrimos el programa le damos al icono de extensiones y actualizamos las que lo necesiten.

[Shell] Reloj binario en C

2014-10-17T13:45:00.000-05:00

Esta ocasión crearemos un reloj binario en C,en el entorno de escritorio KDE,contamos con un reloj binario como applet,me imagine como programar uno y mas adelante colocare el código.

En primer lugar debemos saber como leerlo,en esta ocasión el reloj se basa en cuatro bits,representados por 1 y 0 como realmente se hace,para el bit activo usamos 1 y para el bit apagado usamos 0,el reloj esta representado en formato de 24 horas y cada hora es un Byte de 4 bits un nibble.

Veamos la notación,por ejemplo las 5 de la tarde es 17 en formato de 24 horas,ahora vamos a dividir los números de uno en uno y nos queda 1 y 7,representados en binario son:

1 = 0001
7 = 0111

Bien la lectura binaria la podemos traducir asi de la forma mas fácil,imaginemos que los numero de arriba corresponden a una potencia de 2,comensando por el 1 y luego el 2 mismo,en nuestro caso cuatro bits:

8 4 2 1

Ahora abajo de esos numero colocamos el 0 o 1 que estén activados para que la suma de el numero en notación decimal,por ejemplo 1 y 7:

bits : 8 4 2 1

1 = 0 0 0 1
7 = 0 1 1 1

Bien ahora sumamos los bits que están activos:

1 = 0+0+0+1 = 1 en decimal

7 = 0+4+2+1 = 7 en decimal

Bien eso es todo ahora si el código,el código cuenta con 6 numero en notación binaria,2 para la hora 2 para los minutos y dos para los segundos:

El código se basa en programación funcional y llamamos las funciones una a una en el main.

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

/*
 * Archivo : relojbinario.c
 * Compila : gcc -o relojbinario relojbinario.c
 */


#define BUF_TIME 60
#define BITS 4

typedef enum {
    ZERO = 0x30,
    UNO,
    DOS,
    TRES,
    CUATRO,
    CINCO,
    SEIS,
    SIETE,
    OCHO,
    NUEVE
} Hora;

typedef struct _f_hora {
    int hora_decena[BITS];
    int hora_unidad[BITS];
    int minuto_decena[BITS];
    int minuto_unidad[BITS];
    int segundo_decena[BITS];
    int segundo_unidad[BITS];
} f_hora;

char formato[] = "%k%M%S";
char fecha[BUF_TIME];
void create_clock();
void create_num(char num,f_hora *hora,int i);
void destroy_Binary(f_hora *hora);
void create_binary(f_hora *hora);
void show_clock(f_hora hora);

int main()
{
    f_hora hora;
    create_clock();
    create_binary(&hora);
    show_clock(hora);
    return 0;
}

void create_clock()
{
    struct tm *tiempo;
    time_t ahora = time(0);
    tiempo = localtime(&ahora);
    strftime(fecha,BUF_TIME,formato,tiempo);
}

void create_binary(f_hora *hora)
{
    int len = strlen(fecha),i;
    if (len == 0)
        exit(1);
    for (i = 0;i< len;i++)
        create_num(fecha[i],hora,i);
}

void create_num(char num,f_hora *hora,int iter)
{
    int aux[BITS],i;
    switch((int)num)
    {
        case ZERO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case UNO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case DOS:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case TRES:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case CUATRO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case CINCO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case SEIS:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case SIETE:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case OCHO:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case NUEVE:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        default:
            break;
    }
    for (i=0;i<BITS;i++)
    {
        if (iter == 0)
        {
            hora->hora_decena[i] = aux[i];
        }
        else if (iter == 1)
        {
            hora->hora_unidad[i] = aux[i];
        }
        else if (iter == 2)
        {
            hora->minuto_decena[i] = aux[i];
        }
        else if (iter == 3)
        {
            hora->minuto_unidad[i] = aux[i];
        }
        else if (iter == 4)
        {
            hora->segundo_decena[i] = aux[i];
        }
        else
        {
            hora->segundo_unidad[i] = aux[i];
        }
    }
}

void show_clock(f_hora hora)
{
    int i;
    for (i=0;i<BITS;i++)
    {
        printf("\t%d\t",hora.hora_decena[i]);
        printf("\t%d\t",hora.hora_unidad[i]);
        printf("\t%d\t",hora.minuto_decena[i]);
        printf("\t%d\t",hora.minuto_unidad[i]);
        printf("\t%d\t",hora.segundo_decena[i]);
        printf("\t%d\t",hora.segundo_unidad[i]);
        puts("");
    }
}

Para compilar usamos:

gcc -o relojbinario relojbinario.c

Y si lo ejecutamos en linux podemos llamarlo así,para ver como se ejecuta cada segundo:

while [ 1 ];do sleep 1; clear; ./relojbinario; done

-->

Buscar archivos encriptados con gpg en Linux

2014-07-31T14:31:00.000-05:00

Veamos como encontrar archivos que estén encriptados con GPG usando la herramienta find,esto nos sirve para encontrar archivos previamente encriptados por si posterior mente queremos o intentaremos abrirlos:

Solo abrimos una terminal y ejecutamos:

find ./ -exec file {} \; | grep 'GPG\|PGP'

Esto funciona para cifrado simétrico como el que vimos en la entrada pasada.

Eso es todo :D

Como encriptar carpetas en Linux con GPG

2014-07-31T14:04:00.001-05:00

En esta ocasión vamos a aprender como encriptar una carpeta en Linux,en mi caso Ubuntu 14.04 pero lo podemos hacer con cualquier distribucion de Linux,solo necesitamos tener instalada la herramienta GnuPG que quiere decir : GNU Privacy Guard.

Bien en muchos sistemas con Linux ya biene instalado pero en otros no asi que lo verificamos:

Abrimos una terminal y escribimos:

which gpg; if [[ $? -eq 0 ]]; then echo "Instalado"; else echo "No instalado"; fi

Si no lo tenemos instalado buscamos como instalarlo para nuestra distribución de Linux,de hecho el programa que vamos a usar es gpg-zip,que se instala junto a gpg,en sistemas como Gentoo no se si se instale por las flags usadas al compilar asi que revisar bien a la hora de instalar.

Tutorial

Vamos a ver un ejemplo,tengo un codigo en C importante:

Ahora voy a encriptar esa carpeta,en mi caso estoy usando Dolphin en mi caso este explorador de archivos cuenta con una Terminal empotrada,asi que solo la abro:

En otro caso abren una terminal y van al destino donde tienen la carpeta a encriptar:

Bien ahora encriptamos,nosotros vamos a usar una frase para volver a desencriptar(cifrado simétrico) este usa CAST5, esa opcion la llamamos con el parametro -c:

El programa,así vamos hasta el momento:

gpg-zip -c

Ahora solo debemos mostrar el nombre de salida,al igual que otros programas usamos el parametro -o,asi:

-o salida.gpg

Y por ultimo el nombre de la carpeta,en mi caso prueba,asi queda la linea entera:

gpg-zip -c -o salida.gpg prueba

Al ejecutar esto nos pide una contraseña en GUI:

La escribimos y la reafirmamos y con eso nos crea el fichero cifrado:

Con esto podemos borrar la carpeta original,y podemos ver que es fichero cifrado:

Ahora como lo desencriptamos, con el parametro -d seguido del nombre del gpg,en este caso:

gpg-zip -d salida.gpg

Nos pide la contraseña y vuelve a "crear" el directorio,eso es todo en este caso usamos un cifrado muy común ya que solo usamos contraseña y tar lo que seria como un comprimido con contraseña(no es asi),pero gpg va mas haya con cifrado asimétrico,firmas,etc.

Aqui un script para realizar lo que vimos en esta entrada de una manera facil:

Solo usamos,para desencriptar:

Nombre_script.sh -d nombre.gpg

Para encriptar:

Nombre_script.sh -e carpeta

No cancelar en fase de encriptacion,que borra el folder y no deja respaldo gpg.

#!/bin/bash

function decripta()
{
    echo "Desencriptando $1"
    gpg-zip -d $1
    if [[ $! -eq 0 ]];
    then
        echo "Hecho"
    else
        echo "Algo salio mal :("
        exit
    fi
    rm $1
}

function encripta()
{
    echo "Encriptando $1"
    gpg-zip -c -o $1.gpg $1
    if [[ $! -eq 0 ]];
    then
        echo "Hecho"
    else
        echo "Algo salio mal :("
        exit
    fi
    rm -rf $1
}

function help()
{
    echo "Uso : $0 [-e] Encriptar
                   [-d] Desencriptar
                                     Archivo"

}

case $1 in
    -e)
        if [[ $2 == '' ]];
        then
            help;
        else
            encripta $2
        fi
    ;;
    -d)
        if [[ $2 == '' ]];
        then
            help;
        else
            decripta $2
        fi
    ;;
    '')
        help
    ;;
esac

Eso es todo :D

Eliminar Pelota que Rebota en KDE imposible

2014-07-10T17:07:00.000-05:00

Este tutorial es para poder eliminar el elemento de la pelota roja en el escritorio de KDE,esta pelota esta bien si queremos darle un toque colorido al escritorio,pero lo feo comienza si la configuramos así:

Con rebote automático y con mucha fuerza de rebote,y ni hablar si la encogemos a un tamaño muy pequeño.

Su eliminación es casi imposible y no solo eso,crea un loop que consume mucho cpu :O

Bien para eliminarla vamos a hacerlo desde la consola Konsole,la abrimos y escribimos:

Antes que nada cerramos lo mas importante que estemos haciendo por si algo sale mal:

Eliminamos el escritorio:

kquitapp plasma-desktop

Editamos la configuración:

Con nuestro editor de texto favorito,por ejemplo vim(desde la misma terminal):

vim ~/.kde/share/config/plasma-desktop-appletsrc

O desde un programa gráfico:

kate ~/.kde/share/config/plasma-desktop-appletsrc &

gedit ~/.kde/share/config/plasma-desktop-appletsrc &

Buscamos:

AutoBounceEnabled=true

Y lo cambiamos por

AutoBounceEnabled=false

Reiniciamos plama:

plasma-desktop

Buscamos la pelota y ahora si la quitamos:

Previsualizar Videos y Pdfs en Dolphin Ubuntu

2014-07-10T16:36:00.000-05:00

Dolphin muestra vistas previas de varios archivos como fotos,texto,html,etc pero por defecto no muestra los Videos y PDF,por lo menos en Ubuntu 14.04 con KDE instalado,para poder ver vistas previas hay que hacer varias cosas las cuales muestro a continuación:

1.Instalar lo necesario para ver thumbviews de Vídeos y PDF:

Abrimos una terminal y escribimos:

sudo apt-get install kdegraphics-thumbnailers kffmpegthumbnailer

2. Abrimos la configuración de Dolphin:

Preferencias Dolphin->General->Vistas Previas:

Y activamos todo:

Por ultimo solo activamos el boton de vista previa del menu de Dolphin:

Eso es todo,ejemplo :

Como automatizar nuestros scripts con cron

2014-06-10T18:32:00.001-05:00

Este tutorial es para poder crear scripts "croneados",cron viene de chronos(tiempo),así que podríamos decir que ejecutar scripts cada cierto tiempo,pueden ser scripts en Bash,Perl,Awk o lo que sea,programas en C,C++,etc,mas que scripts son tareas o ordenes.

Por eso se llama así la entrada ya que un script son ordenes,mas que nada seria para ejecutar tareas importantes,como por ejemplo algo relacionado con apache,pero también podríamos poner recordatorios de cosas cotidianas.

Cron es un demonio,en los sistemas de tipo Unix es lo que se conoce como un proceso en segundo plano,cron estaría como "vigilando" el sistema cada cierto tiempo si es que se lo pidiéramos.

Vamos a hacer un ejemplo,tenemos que hacer algo a las cinco de la tarde,y se nos olvida :\ para eso esta cron "a pequeña escala" ya que no es un ejemplo muy bueno a menos que estemos todo el dia en la Pc,pero como podríamos crear un recordatorio en Linux?

Para empezar usamos una notificación,este script sirve:

#!/bin/bash
# Archivo :  ~/.scripts_cron/recordatorio.sh

notify-send "Recordatorio importante"

Por ejemplo lo vamos a guardar en ~/.scripts_cron/

Creamos el directorio:

Desde terminal tecleamos:

mkdir ~/.scripts_cron/

Y lo guardamos con el nombre recordatorio.sh

Le debemos dar permiso de ejecución ya que cron ejecuta ordenes(ejecutables):

chmod +x ~/.scripts_cron/recordatorio.sh

Luego como hacemos que se ejecute en una hora?

Para esto usamos crontab.

Para ello ejecutamos:

crontab -e

Nos abrirá la configuración de nuestro usuario con el editor de consola que tengamos en la variable de entorno EDITOR,para verla:

echo $EDITOR

Si no sale nada puede que el editor sea vi,para definir nano por ejemplo usamos:

export EDITOR=gedit

Si queremos que sea el editor de siempre,ejecutamos:

echo 'export EDITOR=gedit' >> ~/.bashrc

Bien,incluso creo que cron mismo da la opcion de elegir nuestro editor.

La sintaxis de cron es esta:

minuto hora dia mes dia_semana ejecutable

Explico:

minuto es en formato : 0 a 59 si desean siempre(cada minuto),usar *,si desean minutos específicos usar comas.

hora es en formato : 0 a 23 : 0 son las doce de la noche,las doce del dia son 12,ejecutar cada hora usar *,ejecutar horas seleccionadas usar comas.

dia es en formato : día de mes (1-31[dependiendo de los días del mes]),ejecutar todos los días usar *,ejecutar días seleccionados usar comas.

mes es en formato : 1 a 12 o las primeras tres letras del mes en ingles,para ejecutar todos los meses usar *,para ejecutar mas de un mes,usar comas.

dia_semana es en formato : 0 a 6 (domingo es cero,lunes 1,etc),o usar las tres primeras letras del nombre en ingles,para todos los dias usar *,para mas de un dia usar comas.

ejecutable es en formato : /ruta_ejecutable

Bien como ejecutamos el script a las 5 de la tarde,añadimos al final del archivo:

0 17 * * * /home/tu_usuario/.scripts_cron/recordatorio.sh

Eso es todo,ahora deberíamos ver el recordatorio a las cinco,antes que nos confiemos en esto vamos a probar ya que puede haber errores:

Error 1 no esta activo el demonio:

Para saber si esta activo ejecutamos en terminal:

ps -ef | grep cron | grep -v grep

Si no muestra nada lo reiniciamos:

sudo service cron restart

Error 2 ejecutar programas con interfaz gráfica:

Si ejecutamos programas que se muestran en la pantalla debemos setear la variable de entorno DYSPLAY a :0

env DISPLAY=:0

0 17 * * * env DISPLAY=:0 /home/tu_usuario/.scripts_cron/recordatorio.sh

Error 3 nuestro usuario no puede ejecutar tareas con cron:

Puede que nuestro usuario este agregado al archivo:

/etc/cron.deny

Si es así no podemos ejecutar cron,asi que editamos el archivo como root.

Por otro lado el fichero cron.allow permite a los usuarios que esten en el ejecutar cron.

Lo malo es que basado en el sistema que usemos puede que este en distintos directorios,lo buscamos con:

sudo find / -name \cron.deny -type f

Si muestra una ruta la editamos,si no no es este el problema.

Eso es todo,bueno antes de que acabe el tutorial debo aclarar que crontab tiene variables especiales,pero no es muy buena idea usarlas ya que se pueden remplazar con la sintaxis mencionada,la unica variable que no tiene remplazo es la acción de que se ejecute cada vez que se reinicie la Pc:

@reboot

Su uso es así:

@reboot script_a_ejecutar

Eso es todo :D

Tutorial JNI en Linux parte 1

2014-06-07T17:27:00.000-05:00

Este es el primer tutorial de JNI este tutorial forma parte de los de Java solo que es aparte ya que si los escribiera hasta que alcanzáramos este "nivel" de programación seria tardado ya que es de nivel avanzado y en los tutoriales de Java vamos en el 9 de nivel básico,faltarían 11 para entrar en este tema,así que lo veremos de una vez.

Bien primero que es JNI:

JNI son las siglas de de Java Native Interface, JNI es un framework con el cual podemos ejecutar métodos nativos(escritos en C,C++ y assembler),en la maquina virtual de Java,esto hace que podamos usar soluciones de bajo nivel en un programa Java,la JNI se usa para ejecutar código mas veloz que el que este ejecuta en su maquina virtual.

Una consideración de JNI,ademas de otras que existen es que si implementamos métodos nativos Java pierde su "encanto" de que se puede portar donde sea,ya que si abran trabajado con C,C++ sabrán que los programas se hacen específicos para las distintas arquitecturas.

Una cosa buena de JNI es que al aprender a usarlo también nos servirá con Android cuando usemos el NDK.

Antes de empezar,este espacio de trabajo usare:

Sistema : Ubuntu 14.04 o Gentoo

Java version 8 : java version "1.8.0_05"

Editor de texto : Vim

Lenguaje de soporte : C

Compilador : gcc

Depurador : gdb

Terminal : gnome-terminal o konsole

Tutorial

Primero que nada vamos a crear una clase java que implemente un metodo nativo,vamos a hacer el ejemplo de Hola Mundo con JNI,para ello debemos implementar una función nativa en la clase la cual lleva dos modificadores el tipo de funcion y no lleva implementacion,puede lucir asi:

private native void saluda();

El modificador private se usa porque se manipulara desde la propia clase solamente y en inversa el método nativo podrá acceder a elementos de la clase.

native es la palabra reservada para saber que sera un método nativo.

void es el tipo de función o de retorno,en este caso seria un procedimiento al no regresar nada.

saluda() es el nombre del procedimiento y en este caso no lleva parámetros.

Tenemos que hacer una cosa mas,tenemos que cargar la librería nativa,esto lo hacemos llamando la librería .so,que seria por ejemplo libHolaMundo.so, lo hacemos usando el bloque estático static que como mencionamos alguna vez este bloque se carga antes de cualquier cosa,dentro de el usamos la función System.loadLibrary le pasamos como argumento un String con el nombre de la librería sin lib y sin .so:

Por ejemplo:

System.loadLibrary("HolaMundo");

Bien así se ve el código entero:

// Archivo HolaMundo.java

class HolaMundo {
    private native void saluda();
    static {
        System.loadLibrary("HolaMundo");
    }
    
    public static void main(String []args) {
        System.out.println("Hola desde Java");
        new HolaMundo().saluda();
    }
    
}

Ahora debemos compilarlo:

javac HolaMundo.java

Esto nos genera el .class,aun no lo podemos ejecutar ya que necesitamos la librería,lo que debemos hacer es crearla,para ello debemos compilar un .c como .so,pero primero necesitamos crearlo y para ello primero debemos crear una cabecera .h,lo bueno es que java tiene esta utilidad:

Creamos el header:

javah HolaMundo

Ahora bien nos genera el .h y aunque es muy importante no debemos editarlo,incluso nos lo advierten en la primera linea:

Lo que debemos de ver es la funcion que crea,ya que es la que debemos implementar en el .c del mismo:

#include <jni.h>
/* Header for class HolaMundo */

#ifndef _Included_HolaMundo
#define _Included_HolaMundo
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     HolaMundo
 * Method:    saluda
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_HolaMundo_saluda
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

En este caso:

JNIEXPORT void JNICALL Java_HolaMundo_saluda (JNIEnv *, jobject);

Como vemos contiene dos Macros:

JNIEXPORT y JNICALL,los cuales se encargan de ejecutar correctamente la función.

Cambien tenemos el tipo de función en este caso void,como es un tipo similar al de c no hay problema ,pero veremos otros si fuera por ejemplo una función int,veríamos un jint,o una función String veríamos un jstring,etc.

Vemos el nombre de la función dividido en tres partes:

Java, el nombre de la clase y el nombre de la función escrita en la clase.

Por ultimo vemos dos argumentos?

Pero porque dos argumentos si no le pasamos nada desde java,estos son un JNIEnv que es el entorno,el que usaremos para toda la manipulación de datos de java,y un jobject que es la representación de la clase misma de Java(la que llama al programa en C).

Bien ahora si vamos a crear el .c,el cual no hará casi nada solo implementar esa función:

En la primera linea debemos o deberíamos llamar a jni.h pero como ya lo llamamos en el HolaMundo.h no es necesario,aunque podemos hacerlo,luego incluimos el stdio.h como siempre y por ultimo creamos la función que nos muestra el .h,prácticamente podemos copiar y pegar,pero no ya que aunque el .h define los dos argumentos que vamos usar no define los nombres,así queda el .c:

#include <stdio.h>
#include "HolaMundo.h"


JNIEXPORT void JNICALL Java_HolaMundo_saluda
  (JNIEnv * env, jobject obj)
{
    puts("Hola desde JNI");
}

Bien ahora solo queda crear el .so,para ello debemos compilar llamando las librerias necesarias,en mi caso(por la versión de java que uso):

gcc -shared -I/usr/lib/jvm/java-8-oracle/include/ -I/usr/lib/jvm/java-8-oracle/include/linux/ -o libHolaMundo.so HolaMundo.c -Wall

Lo que esta en rojo es lo que debemos cambiar(o tal vez no):

Eso es todo ahora basta ejecutar,pero debemos redefinir o agrear el PATH actual al LD_LIBRARY_PATH,para que podamos usar la librería que acabamos de crear ya que actualmente esta en . y no donde java lo pide :

export LD_LIBRARY_PATH=.

Ejecutamos;

java HolaMundo

Si deseamos modificar un archivo debemos ejecutar todo de nuevo,el javac,el javah,el gcc así que podemos crear un script en bash para automatizarlo,bueno eso me sirve a mi,vean este seria:

NAME=HolaMundo # Editar

PJAVA=java-8-oracle # Editar

function genera(){
echo "Ejecutando javac $NAME.java"

javac $NAME.java

echo "Ejecutando javah $NAME"

javah $NAME
}

function compila() {
echo "Ejecutando gcc"

gcc -shared -I/usr/lib/jvm/$PJAVA/include/ -I/usr/lib/jvm/$PJAVA/include/linux/ -o lib$NAME.so $NAME.c -Wall

}

function ejecuta() {
echo -e "Ejecutando $NAME\n"

java $NAME
}

function ayuda() {
echo "$0
         -h : ayuda
         -g : generar .h
         -e : ejecutar
         -c : compila
         -a : ejecutar todo
    "
}

case $1 in
    -e)
        ejecuta
    ;;
    -g)
        genera
    ;;
    -c)
        compila
    ;;
    -a)
        genera
        compila
        ejecuta
    ;;
    -h|"")
        ayuda
    ;;
esac

Así solo ejecutamos:

bash exec.sh -a

Todo lo que acabamos de hacer,crear el .java el .h,el .c,el .sh(opcional) siempre lo vamos a hacer,así que esa era la introducción a JNI,ahora lo que sigue es saber usar el API,manejar funciones y tipos de datos de jni.h,usar,obtener,devolver y modificar objetos de java desde el código .c.

Vamos a hacer una función saludar mejorada esta función saludara a un nombre que le pasemos,para eso modificamos la función de la clase HolaMundo.java para que quede así:

private native void saluda(String nombre);

También modificamos la llamada,que esta mas abajo:

new HolaMundo().saluda("nombre");

Ahora compilamos y generamos el .h:

bash exec.sh -g

javac HolaMundo.java

javah HolaMundo

Bien luego debemos editar el .c,ya que si vemos el .h,cambio y nos pasa un argumento mas:

jstring

Para usar la String que nos pasa Java debemos crear una referencia a un tipo const char, y luego apuntar al String,primero seria así:

const char * nombre;

Luego tenemos que pedir la String con la función GetStringUTFChars o GetStringChars de jni la cual nos devuelve el String en UTF-8 o Unicode,le pasamos tres argumentos,el primero es el entorno,el segundo es el jstring y el ultimo un jboolean,este no nos interesa,podemos ponerlo en NULL o en JNI_TRUE.

Para llamar una función de JNI usamos un puntero de env simulando una clase de C++,así:

(env*)->funcion

Así es como quedaría:

nombre = (*env)->GetStringUTFChars(env,name,NULL);

name es el nombre del parámetro jstring,no del nombre del const char.

Ya se podria usar este código,pero tenemos que seguir las normas de todo programador C, ver si se creo el puntero(si no es igual a NULL) y liberar la memoria del puntero.

Lo primero es fácil:

if (nombre == NULL) {
return; // Terminamos la funcion
}

Lo segundo se logra con una funcion propia de la API,no es simplemente usar free(),esa funcion es:

ReleaseStringUTFChars o ReleaseStringChars dependiendo con cual creamos el puntero.

Le posamos tres argumentos,el entorno,el jstring y el puntero a jstring,el const char,en este caso:

(*env)->ReleaseStringUTFChars(env,name,nombre);

Eso es todo,asi queda el código completo:

#include <stdio.h>
#include "HolaMundo.h"

JNIEXPORT void JNICALL Java_HolaMundo_saluda
  (JNIEnv * env, jobject obj,jstring name)
{
    const char *nombre;
    nombre = (*env)->GetStringUTFChars(env,name,NULL);
    if (nombre == NULL)
    {
        return;
    }

    printf("Hola desde JNI : %s\n",nombre);

    (*env)->ReleaseStringUTFChars(env,name,nombre);
    
}

Compilamos:

gcc -shared -I/usr/lib/jvm/$PJAVA/include/ -I/usr/lib/jvm/$PJAVA/include/linux/ -o lib$NAME.so $NAME.c -Wall

bash exec.sh -c

Y ejecutamos:

java HolaMundo

bash exec.sh -e

Por ultimo vamos a ver como podriamos retornar una String,supongamos que queremos hacer un algoritmo en C que cambie las palabras del string por el simbolo que sigue,esto es facil en C,luego lo retormamos y lo imprimimos en Java:

Así queda la clase Java:

// Archivo : HolaMundo.java

class HolaMundo {
    private native void saluda(String nombre);
    private native String encripta(String palabra);
    static {
        System.loadLibrary("HolaMundo");
    }
    
    public static void main(String []args) {
        System.out.println("Hola desde Java");
        new HolaMundo().saluda("Atheyus");
        System.out.println(new HolaMundo().encripta("Tiempo de Tux"));
    }
    
}

Compilamos y generamos el .h:

bash exec.sh -g

El HolaMundo.h luce asi en estos momentos:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class HolaMundo */

#ifndef _Included_HolaMundo
#define _Included_HolaMundo
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     HolaMundo
 * Method:    saluda
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_HolaMundo_saluda
  (JNIEnv *, jobject, jstring);

/*
 * Class:     HolaMundo
 * Method:    encripta
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_HolaMundo_encripta
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

Lo implementamos en el .c,así queda:

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

JNIEXPORT void JNICALL Java_HolaMundo_saluda
  (JNIEnv * env, jobject obj,jstring name)
{
    const char *nombre;
    nombre = (*env)->GetStringUTFChars(env,name,NULL);
    if (nombre == NULL)
    {
        return;
    }

    printf("Hola desde JNI : %s\n",nombre);

    (*env)->ReleaseStringUTFChars(env,name,nombre);
}

JNIEXPORT jstring JNICALL Java_HolaMundo_encripta
  (JNIEnv * env, jobject obj, jstring word)
{
    const char *nombre;
    nombre = (*env)->GetStringUTFChars(env,word,NULL);
    if (nombre == NULL)
    {
        return NULL;
    }
    int size = (*env)->GetStringUTFLength(env,word);
    char encripta[size];
    char tnombre[size];
    strcpy(tnombre,nombre);
    int i;
    for (i=0;i<size;i++)
        encripta[i] = (tnombre[i]+1);
    jstring word_en = (*env)->NewStringUTF(env,encripta);
    (*env)->ReleaseStringUTFChars(env,word,nombre);
    return word_en;
}

Eso es todo compilamos y ejecutamos:

Para lograr eso en Java usaríamos StringBuilder,u otra opción pesada,pero en C asi seria,muy veloz,no voy a explicar las funciones dejo la documentación de ellas y de otras mas en el enlace que sigue:

Enlace

Tutorial Java en Linux Basico 9

2014-06-05T15:59:00.001-05:00

Interfaces

Antes que comenzar con la entrada,quiero mencionar que ya no había hecho entradas desde hace mucho tiempo por distintas razones,espero que ya pueda volver a escribir entradas,tutoriales con la recurrencia de antes.

Bien en este caso veremos la interfaces de java,no son interfaces gráficas(GUI) si no una implementacion de un tipo del propio lenguaje,así que esta entrada no esta relacionada con las interfaces graficas como Gtk,AWT,etc.

Una interfaz es algo muy raro en Java,mas si tienen como base o vienen de lenguajes como Python,Ruby o Perl,si vienen de C o C++,podríamos decir que es como una cabecera de archivo,pero tampoco,así que olviden lo que saben de esos lenguajes y háganse una idea nueva de esta forma de programar.

Las interfaces en Java sirven para varias cosas,unas de ellas son:

Polimorfismo.

Programación en equipo : Uso de plantillas.

Abstracción.

Herencia: Mas o menos.

Primero que nada debe quedar claro que una interfaz es una clase que no hace nada,sabe que debe hacer pero no sabe como hacerlo,digamos que es un tipo de asesor de clases,los métodos o procedimientos incluidos en las interfaces son abstractos,lo que quiere decir que no hacen nada hasta que se implementen en la clase que los use,para definiros hay que recordar que se escriben así:

abstract void hola(int parametro);

En void es el tipo de función o si es un procedimiento es void.

En hola es el nombre de la función o procedimiento.

en (int parámetro) van los parámetros o los dejamos vació si es que no lleva alguno.

No lleva llaves,ni siquiera vacías.

Bien,una interfaz va en su propio archivo y igual que las clases se llama igual que dicho archivo,es .java:

Vamos usar el ejemplo mas usado(que es el mejor):

Creamos una interfaz Poligono,el cual representa figuras geométricas,la clase tendrá las funciones para sacar la Area y el Perimetro de una figura:

package figuras;

public interface Poligono {
 public abstract void Area();
 public abstract void Perimetro();
}

Vamos a crear tres clases mas,la primera es el main,Figuras.java:

package figuras;

public class Figuras {
 public static void main(String args[]) {
  // Codigo
 }
}

La segunda va a ser una abstracción de un cuadrado que implemente la interfaz Polígono y defina las funciones de Área y Perímetro:

Para implementar una interfaz se usa la palabra implements seguida del nombre de la clase o de la clase que herede la clase,si se implementan varias interfaces se usan comas:

package figuras;

public class Cuadro implements Poligono{
 private int lado;
 Cuadro(int lado) {
  this.lado = lado;
 }
 
 public void Area() {
  int area = this.lado * this.lado;
  System.out.println("Area : "+area);
 }

 public void Perimetro() {
  int perimetro = this.lado+this.lado+this.lado+this.lado;
  System.out.println("Perimetro : "+perimetro);
 }

}

Bien como vemos los métodos abstractos ya los esta usando la clase Cuadro,algo muy importante es que los métodos se deben escribir si o si en la clase que los implemente o de lo contrario dará un error,si la clase no los usa pero si los define se puede usar esta sintaxis,por ejemplo :

public void Perimetro() { ; };

Aquí es donde comienza el upcasting,podemos definir un cuadro de la siguiente manera:

La manera normal seria:

Cuadro cuadro = new Cuadro(30);

Pero podemos hacerlo desde la clase heredada(que es una interfaz),subiendo un nivel en la cadena:

Poligono cuadro = new Cuadro(30);

Y no hay ningún problema.

El otro ejemplo que les mencionaba de el uso de interfaces como plantillas es que digamos que un programador encargado de pensar la idea de un programa crea una interfaz que tienen que definir los métodos otros programadores,pero cada uno lo hará diferente,basado en la necesidad del objeto que debe crear,saben que deben hacer basados en la interfaz,pero les toca implementar el método.

A pequeña escala supongamos que el primer programador tenia que hacer un Cuadro,ya lo hizo y otro tiene que hacer un Rectangulo,lo cual se vería así:

package figuras;

public class Rectangulo implements Poligono {
 int base;
 int altura;
 Rectangulo(int base,int altura) {
  this.base = base;
  this.altura = altura;
 }
 
 public void Area() {
  int area = this.base * this.altura;
  System.out.println("Area : "+area);
 }

 public void Perimetro() {
  int perimetro = (this.base+this.base)+(this.altura+this.altura);
  System.out.println("Perimetro : "+perimetro);

 }

}

Ahora si en la clase principal podemos usarlos:

package figuras;

public class Figuras {
 public static void main(String args[]) {
  Poligono cuadro = new Cuadro(30);
  cuadro.Perimetro();
  cuadro.Area();
  Poligono rectangulo = new Rectangulo(20, 10);
  rectangulo.Area();
  rectangulo.Perimetro();
 }
}

Eso es todo :D.

Como instalar Brackets en Ubuntu 14.04

2014-04-23T12:33:00.000-05:00

Brackets es un editor open source para desarrollo web,es de adobe y en teoría es pariente de dreamweaver.

Yo no soy programador o diseñador web pero aun así hay que saber un poco de todo,y si he hecho algunas cosas en HTML5,CSS3,Javascript usando algunas herramientas OpenSource pero hasta ahora este es el que mas me ha gustado(y no es publicidad),simplemente hay que reconocer que este es un gran editor.

Lo que me gusto de este editor es:

Plugins(extensiones),hechos por la comunidad para extender el editor y fácil instalación:

Temas,uno puede programar a blanco y negro pero los temas nos animan mas a trabajar:

Autocompletado de palabras(se extiende a javascript,JQueryMobile gracias a plugins).

Vista previa en vivo:

Cada vez que guardemos(Ctrl+S) recarga la pagina que estamos creando en el editor que abre al iniciar la vista en vivo(el que tengamos configurado en el sistema por defecto):

Vista de imágenes,al colocar una url de una imagen,sea en css,javascript o html,nos da una previsualizacion:

Entre muchas mas cosas.

Tutorial de instalacion:

Bien podemos hacerlo por PPA,con unos simples comandos:

Abrimos una terminal y escribimos:

sudo add-apt-repository ppa:webupd8team/brackets

sudo apt-get update

sudo apt-get install brackets

O podemos hacerlo desde el .deb:

Bajamos el paquete .deb:

http://brackets.io/

Luego abrimos una terminal y nos pasamos a la carpeta de Descargas(o donde descargue los archivos su navegador):

cd Descargas

Y escribimos para instalar:

sudo dpkg -i Brackets.*.deb && sudo apt-get -f install

Buscamos en el Dash:

Eso es todo :D

Y recuerda si te sirvió y tienes cuenta de google dale google aya abajo

Como actualizar Ubuntu 13.10 a 14.04

2014-04-22T14:58:00.001-05:00

Este es un tutorial rápido para hacer un upgrade de Ubuntu 13.10 a Ubuntu 14.04.

Abrimos una terminal(Ctrl+Alt+T) y escribimos:

sudo apt-get update && sudo apt-get dist-upgrade

Con eso se actualizan los repositorios y paquetes actuales,ahora solo verificamos si hay una version nueva:

sudo update-manager -d

Solo indicamos que si queremos actualizar,y esperamos.

Se va a tardar un rato en descargar y instalar cerca de 700mb/1gb de datos,no coloco capturas porque ya esta actualizado mi sistema:

Como destruir sesion de Ubuntu congelado

2014-04-16T22:04:00.000-05:00

Bien,esto es para los que aun pueden mover el puntero o entrar a una tty.

Digan lo que digan en Linux tenemos problemas,no tan populares como las pantallas azules de Windows pero en ocasiones se "rompe" algo y nuestro sistema se congela,en el caso de Ubuntu no se porque,me ha pasado a nivel de modulo con los gráficos de intel pero en esta ocasion dmesg no dijo nada,debió haber sido unity.

Para poder seguir usando la pc sin tener que reiniciarla a la brava podemos matar el proceso del servidor grafico,esto lo uso asi porque Linux me ha dado ese problema,sea Gentoo-KDE,Arch-GNOME-SHELL,Debian,etc siempre se ha congelado mi sistema(sera mi pc).

Para matar el proceso de Xorg solo hacemos esto:

Abrimos una tty:

Ctrl+Alt+F1

Ctrl+Alt+fn+F1

Nos logeamos.

Ahora matamos el proceso Xorg

sudo killall Xorg

O nos logeamos como root y tecleamos:

killall Xorg

Con eso eliminamos todo lo que tiene que ver con Xorg y en Ubuntu esto nos mostrara automáticamente la pantalla de login para entrar de nuevo,no es la mejor practica pero podemos entrar de nuevo a nuestro usuario.

Esto elimina los procesos,así que si tenemos por ejemplo un documento que aun no salvamos,no se guardara,a menos que tenga un servicio que guarde automaticamente cada cierto tiempo,y en teoria se debe seguir ejecutando ya que el sistema nos deja acceder a otras partes del mismo,el problema es solo que el entorno de escritorio no responde.

En el peor de los casos el sistema entero se cae y no nos deja ni siquiera mover el mouse o entrar a una tty o apagar la pc.

En el futuro hablaremos de como pausar procesos para salvarlos o migrarlos a otra shell,aunque sean los de terminal.

Y recuerda si te sirvió y tienes cuenta de google dale google aya abajo

Poder hacer debug con dispositivos Inco Eclipse Linux

2014-04-12T13:54:00.002-05:00

Esto es para las tablets llamadas chinas,ya que el adb no las detecta.

Un poco de historia:

Me toco comprar varios dispositivos android para probar distintas apps que estoy programando,ya que aunque eclipse pueda emular android virtuales no hay como probar la app en la vida real(un dispositivo real),para no gastar mucho compre algunos dispositivos Inco ya que lo único que quiero ver es el posicionamiento de los layout en distintas pantallas,así que esa marca me sirve por lo menos para las tabletas.

Esta marca son de las llamadas tablets o smartphones chinos(como algunas otras marcas),no son muy buenos como los Samsung,LG,Motorola,Nexus pero lo que sea de cada quien sirven muy bien(para el precio que vale) y eso que lo comparo con un iPad o Galaxy tab bien basta de historia.

Tutorial

Linux no detecta estos dispositivos chinos,si los detecta pero no así el adb, o enteramente ya que solo se visualiza el BUS:

Si lo vemos que el adb tampoco lo muestra:

adb devices -l

Para que lo "agarre" el sistema, tenemos que añadir su ID al servicio android:

Por ejemplo el mio es:

1f3a:1002

Tomamos el primero y usamos notación HEX:

cho '0x1f3a' >> ~/.android/adb_usb.ini

Tambien añadimos esto en las reglas de android:

Abrimos para editar:

sudo nano /etc/udev/rules.d/51-android.rules

Código es la notación HEX de 3 digitos quitando el primero del ID de tu tablet,por ejemplo:

1f3a

El código seria:

f3a

SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device",
SUBSYSTEM=="usb", ENV{PRODUCT}=="codigo/*", MODE="0666"
SUBSYSTEM=="usb", SYSFS{idVendor}=="codigo", MODE="0666"

Eso es todo,ahora solo reiniciamos la pc o si no pueden, reinician el servicio de adb:

adb kill-server && adb start-server

Veamos:

En eclipse:

Eso es todo sirve para otros modelos Inco y creo que para mas tablets chinas(si no es que todas),el hecho es que lo reconozca Linux y este bien configurada la tablet para el modo debug dependiendo de la versión adroid que este ejecutando.

Convertidor de videos para Ubuntu 13.10 HandBrake

2014-04-12T12:14:00.000-05:00

En Ubuntu o en los sistemas GNU/Linux tenemos algunos programas para convertir vídeos,este en especial me gusta:

Es Open Source y solo necesitamos instalar y ya,no necesitamos soporte extra como en el caso de ffmpeg , solo instalamos y listo :D

Este convertidor sirve muy bien para los ipod touch o iphone,en el caso de ipod touch,solo sirve de la version 4g para arriba,una version menor tenemos que convertirlos usando el codec ipod sin soporte para 5g:

Tiene opciones de Video,Audio,Subtitulos y Metadatos.

Bien para instalar lo podemos hacer por PPA:

Primero abrimos una terminal(Ctrl+Alt+T):

Escribimos:

sudo add-apt-repository ppa:stebbins/handbrake-releases && sudo apt-get update

Y instalamos:

sudo apt-get install handbrake-gtk

Para 64 bit podemos hacerlo desde el .deb:

mkdir ~/handbrake && cd ~/handbrake

wget -c https://launchpad.net/~stebbins/+archive/handbrake-releases/+files/handbrake-gtk_0.9.9ppa1~raring1_amd64.deb

sudo dpkg -i handbrake-gtk_0.9.9ppa1~raring1_amd64.deb && sudo apt-get install -f

Abrimos,buscamos en el Dash:

O en la terminal si aun esta abierta escriben:

ghb & exit

Ahora a disfrutar o usar :D.

Tutorial Java en Linux Basico 8

2014-04-11T13:26:00.000-05:00

Estructuras dinámicas

En esta ocasión vamos a ver como declarar estructuras dinámicas en java,las llamadas arrays.

En ocasiones anteriores hemos visto los arreglos de una dimensión llamados vectores y de dos llamados matrices,a diferencia de los arreglos comunes que acabo de mencionar los arrays deben o son dinámicos en tamaño no estáticos,por ejemplo al definir un vector de 10 elementos de tipo int tenemos que hacer esto:

Integer elementos[] = new Integer[10];

Pero si quisiéramos o mejor dicho si no supiéramos cuantos elementos va a tener el arreglo como le haríamos?

Aquí es donde entra ArrayList lo que seria como una simple lista en lenguajes como python o ruby.

Listas

Para usar ArrayList tenemos que importarlo:

import java.util.ArrayList;

Su constructor es este:

ArrayList elementos = new ArrayList();

De esta manera seria idéntico a un lenguaje de alto nivel(fácil) crear una lista,a lo que me refiero es que podemos crear una lista de distintos tipos de datos,int,string,float,etc a diferencia de lo que seria un vector de un solo tipo de dato:

Para añadir un elemento usamos el método add pasándole como parámetro el dato a usar,por ejemplo:

elementos.add("Hola Mundo"); // String

elementos.add(10); // int

elementos.add('a'); // char

Bien,aun asi cuando los llamemos se convertiran a un tipo envuelto:

int a Interger

char a Character // etc

Aun así no es muy recomendable usar este tipo de listas(con datos de muchos tipos),lo recomendable es usar un dato de un solo tipo ya que incluso el compilador muestra un error.

Para definir el tipo de datos que vamos a usar lo añadimos al lado del constructor entre etiquetas:

ArrayList arreglo = new ArrayList();

En donde tipo usamos un tipo envuelto,por ejemplo:

ArrayList arreglo = new ArrayList();

Primero vamos a ver los métodos de agregar y de obtener:

arreglo.add(10);

arreglo.add(120);

Ya hemos comentado el método add,para obtener un elemento del arreglo usamos el método get y le pasamos como parámetro el índice(comienza a contar desde 0) del elemento:

arreglo.get(10);

Si queremos ver el tamaño de un arreglo usamos el método size que nos devuelve un int,por ejemplo para recorrer los elementos de un array:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));

Antes de ver las otras funciones podemos ver que añadir tiene otra función,la cual es diferente,mientras el add normal "apila" los datos uno sobre otro,este otro add puede añadir un dato en cierta posición:

arreglo.add(posición,elemento);

Eso seria como un remplazar.

Bien ahora vamos a ver las formas de iterar los elementos de un array,forma uno:

Esta ya la vimos:

for (int i = 0;i < arreglo.size();i++)
    System.out.println(arreglo.get(i));

Forma dos:

Con un bucle foreach,donde Integer es el tipo de Objeto.

for (Integer x: arreglo) {
    System.out.println(x);
}

Forma tres con un Iterator,donde Integer no es el tipo de objeto.

import java.util.Iterator;

Iterator i = arreglo.iterator();

while(i.hasNext()) {
    System.out.println(i.next());
}

Bien que mas podemos hacer?

Tenemos mas funciones:

arreglo.clear(); // Limpia el array(lo resetea)

arreglo.contains(elemento); // Devuelve true si existe el elemento en el array

arreglo.remove(indice); // elimina un elemento basado en el índice

arreglo.remove(elemento); // elimina un elemento basado en el elemento

arreglo.toArray(); // Devuelve un array (Object[])

arreglo.indexOf(elemento); // Devuelve el índice del elemento contando desde la izquierda

arreglo.lastIndexOf(elemento); // Devuelve el índice del elemento contando desde la derecha

Hashes

Ahora vamos a ver como usar los arreglos asociativos o has tables,los cuales se usan igual que las listas solo que se usan con clave valor en vez de índice valor:

Para definir un Hashtable,primero lo importamos:

import java.util.Hashtable;

Ahora usamos este constructor:

Hashtable hash;

Los dos objetos son los que usaremos para clave y valor,se recomienda usar String para clave,por ejemplo:

Hashtable hash = new Hashtable();

Ahora vamos a ver como añadir elementos:

Usamos:

hash.put(clave,valor);

Por ejemplo usando el hash de arriba:

hash.put("uno",1);
hash.put("diez",10);
Ahora tenemos dos elementos en el hash,como los recuperamos?

hash.get(clave);

Por ejemplo:

hash.get("uno"); // devuelve 1

Tenemos funciones similares al de ArrayList:

hash.clear(); // Resetea el hash

hash.containsKey(clave); // Devuelve true si contiene la clave

hash.containsValue(valor); // Devuelve true si contiene el valor

hash.isEmpty(); // Devuelve true si esta vacio

hash.remove(clave); // Quita el objeto basado en clave

Como iteramos?

Aquí es un poco mas complicado ya que no podemos usar índices,pero aun así tenemos algunas opciones:

La primera opciones es usando Collection ,primero importamos:

import java.util.Collection;

Ahora creamos un objeto Collection,esta nos devolverá los valores:

Collection col = hash.values(); // En donde Integer es el tipo de objeto de los valores
Luego creamos un Iterator,como con ArrayList y iteramos:

Iterator i = col.iterator();
while(i.hasNext()) {
System.out.println(i.next());
}

Forma 2:

Esta otra forma es mas sutil ya que podremos usar las llaves y los valores,es usando Enumeration:

import java.util.Enumeration;

Enumeration en = hash.keys(); // En donde String es el tipo de Objeto de las claves

Bien ahora solo iteramos:

while(en.hasMoreElements()) {
String key = en.nextElement();
System.out.printf("Clave : %s Valor : %s\n",key,hash.get(key));
}

Eso es todo :D

Como usar adobe flash en Firefox Nightly Gentoo

2014-03-05T19:09:00.000-06:00

Si han descargado firefox en su versión Nightly sabran que viene listo para usarse,como son conocidos los paquetes tar,bien estos paquetes no linkean los .so de nuestras librerias,asi que no reconoce el flash:

Para hacerlo solo basta copiar el libflashplayer.so a la carpeta de plugins de mozilla:

Primero necesitamos tener instalado adobe-flash(o pueden bajar el tar desde su sitio):

Enlace

Por emerge:

sudo emerge -av www-plugins/adobe-flash

Ahora solo tecleamos esto:

Creamos el directorio:

mkdir -p ~/.mozilla/plugins/

Linkeamos:

su

ln -S /usr/lib/nsbrowser/plugins/libflashplayer.so ~/.mozilla/plugins/

Y cambiamos los permisos de usuario:

chown tu_usuario ~/.mozilla/plugins/libflashplayer.so

Eso es todo:

Torbrowser no detecta teclas en Ubuntu 13.10

2014-02-18T12:20:00.000-06:00

Hace poco queria usar Tor browser,y no me detecto las teclas por un error de IBUS,este :

IBUS-WARNING **: Events queue growing too big, will start to drop.

Bueno lo que podemos hacer es un X11 forwarding,para ejecutar Tor,esto es muy sencillo:

Necesitamos tener instalado opensshserver:

sudo apt-get install openssh-server

Ahora en la carpeta donde esta el script que inicia tor(start-tor-browser):

ssh -X localhost $PWD/start-tor-browser

Así de sencillo:

Tal vez con una actualización ya no ocurra este error.

Y recuerda si te sirvió y tienes cuenta de google dale google aya abajo

[Kali Linux] Efectuar MitM para ver urls

2014-02-14T14:24:00.001-06:00

Como estoy haciendo una serie de tutoriales de pentest,no tanto en si pentest si no hasta ahora uno de spam otro de information gathering otro de otra cosa,pero bueno se entiende el propósito,para que se entienda mejor y sea mas sencillo estas practicas recomiendo usar Kali Linux,puede ser Blackbuntu,BlackArch u otra distribución de Linux enfocada a la seguridad informatica. Yo en lo personal me gusta Kali pero en cualquier sistema Linux se pueden instalar los programas que aquí he mencionado y voy a mencionar aunque sea compilando,así que si no tienen las herramientas en su sistema y no tienen Kali Linux pueden buscar como instalar dicha herramienta en su sistema,sea Ubuntu,Arch,openSUSE,Gentoo,Fedora,etc.

Disclamer

Este tutorial es con fines de obtener conocimiento sobre el tema a nivel basico,la ejecución del mismo esta bajo el criterio del leector.

Bien,este tutorial lo pueden efectuar incluso sobre su localhost asi que no hay mucho problema si no tienen una segunda maquina donde hacer las pruebas.

Primero que nada que es MitM:

En criptografía, un ataque man-in-the-middle o JANUS (MitM o intermediario, en español) es un ataque en el que el enemigo adquiere la capacidad de leer, insertar y modificar a voluntad, los mensajes entre dos partes sin que ninguna de ellas conozca que el enlace entre ellos ha sido violado. El atacante debe ser capaz de observar e interceptar mensajes entre las dos víctimas. El ataque MitM es particularmente significativo en el protocolo original de intercambio de claves de Diffie-Hellman, cuando éste se emplea sin autenticación.

Ataques:

El ataque MitM puede incluir algunos de los siguientes subataques:

Intercepción de la comunicación (eavesdropping), incluyendo análisis del tráfico y posiblemente un ataque a partir de textos planos (plaintext) conocidos.
Ataques a partir de textos cifrados escogidos, en función de lo que el receptor haga con el mensaje descifrado.
Ataques de sustitución.
Ataques de repetición.
Ataque por denegación de servicio (denial of service). El atacante podría, por ejemplo, bloquear las comunicaciones antes de atacar una de las partes. La defensa en ese caso pasa por el envío periódico de mensajes de status autenticados.

Fuente : es.wikipedia.org

Lo que nosotros vamos a realizar en este tutorial es un eavesdropping pero solo el analisis de trafico a nivel "humano" ya que podemos ver los datos en hex,pero aquí veremos las url directas.

Tutorial

Un nivel Script Kiddies(automatizando con herramientas existentes),es el siguiente:

Usando websploit

Websploit nos probe una shell como la de Metasploit,como la que hice para ver los exif de una imagen.

Al ejecutar el programa:

websploit

Podemos ver la ayuda con help,al igual que metasploit cuenta con diferentes modulos,nosotros usaremos una para MitM:

use network/mitm

Vemos las opciones:

show options

Como vemos tenemos algunas opcines,vamos a setearlas:

set interface interfaz

set router gateway

set target ip_victima

set sniffer urlsnarf

En interfaz es la interfaz de nuestra red,si estamos por cable ethx,si estamos por wirless,wlanx.

En router ponemos la puerta enlace,para verla desde consola:

netstat -nr

En target ponemos la ip victima,podemos obtenerla haciendo un scan rango 24 con nmap al gateway:

nmap -sP gateway/24

o podemos poner nuestra propia ip dinamica,para no molestar a alquien mas y hacer pruebas.

En sniffer ponemos urlsnarf,este programa nos mostrara las url que esta viendo la ip que asignamos en target.

Ahora solo ejecutamos con:

run

Bien,con eso hacemos todos,cuendo comience a navegar el target nos mostrara las urls.

Ahora un nivel mas bajo,teclear todo nosotros mismos para ver por lo menos como se hace esto:

Primero que nada hacemos ip forward,en linux es tan facil como setear a uno la configuracion del archivo correspondiente:

echo 1 > /proc/sys/net/ipv4/ip_forward

Ahora tenemos que redirigir el trafico del puerto 80 basado en reglas de iptables,por ejemplo al puerto 8080:

iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080

Con eso esta listo el enrutamiento.

Ahora vamos a ver lo necesario,gateway y target:

Gateway:

route | sed -n "3p"

Targets:

nmap -sP gateway/24 | grep --color for

Con eso tenemos la informacion necesaria.

Ahora solo falta la suplantacion de ARP:

arpspoof -i interfaz -t gateway ip_victima

Lo podemos hacer dual para no errar.

Ahora solo ejecutamos urlsnarf,para analizar las urls luego lo redirigiremos con un estándar de unix:

urlsnarf -i interfaz >> captura

Para ver el resultado podemos hacerlo con cat,less,more:

cat captura

O podemos sacar las urls directamente con,una regex,por ejemplo con perl en una tuberia Unix:

cat captura | perl -lane 'while ($_ =~ m/\"(.+)\"/ig){ print $1."\n"}' | grep --color http://

Eso es todo.

Y recuerda si te sirvió y tienes cuenta de google dale google aya abajo