Punto Libre

Feliz & Prospero Año Nuevo 2012

2012-01-02T04:41:00.000-08:00

Un Año Nuevo lleno de amor, paz, prosperidad y mucha felicidad

es mi más puro deseo para todos ustedes.

Feliz año nuevo a todos!

Estructuras de Control

2011-12-07T17:17:00.000-08:00

Las estructuras de programación o estructuras de control permiten tomar decisiones y realizar un proceso repetidas veces. Son los denominados bifurcaciones y bucles. En la mayoría de los lenguajes de programación, este tipo de estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de un lenguaje a otro. La sintaxis de Java coincide prácticamente con la utilizada
en C/C++, lo que hace que para un programador de C/C++ no suponga ninguna dificultad adicional.

Sentencias o expresiones

Una expresión es un conjunto variables unidos por operadores. Son órdenes que se le dan al computador para que realice una tarea determinada.
Una sentencia es una expresión que acaba en punto y coma (; ). Se permite incluir varias sentencias en una línea, aunque lo habitual es utilizar una línea para cada sentencia. Por ejemplo:

i = 0; j = 5; x = i + j;// Línea compuesta de tres sentencias

Comentarios

Existen dos formas diferentes de introducir comentarios entre el código de Java (en realidad son tres, como pronto se verá). Son similares a la forma de realizar comentarios en el lenguaje C++. Los comentarios son tremendamente útiles para poder entender el código utilizado, facilitando de ese modo futuras revisiones y correcciones. Además permite que cualquier persona distinta al
programador original pueda comprender el código escrito de una forma más rápida. Se recomienda acostumbrarse a comentar el código desarrollado. De esta forma se simplifica también la tarea de estudio y revisión posteriores.

Java interpreta que todo lo que aparece a la derecha de dos barras “//” en una línea cualquiera del código es un comentario del programador y no lo tiene en cuenta. El comentario puede empezar al comienzo de la línea o a continuación de una instrucción que debe ser ejecutada. La segunda forma de incluir comentarios consiste en escribir el texto entre los símbolos /*...*/. Este segundo
método es válido para comentar más de una línea de código. Por ejemplo:

// Esta línea es un comentario
int a=1; // Comentario a la derecha de una sentencia
// Esta es la forma de comentar más de una línea utilizando
// las dos barras. Requiere incluir dos barras al comienzo de cada línea
/* Esta segunda forma es mucho más cómoda para comentar un número elevado de líneas
ya que sólo requiere modificar
el comienzo y el final. */

En Java existe además una forma especial de introducir los comentarios (utilizando /**...*/ más algunos caracteres especiales) que permite generar automáticamente la documentación sobre las clases y packages desarrollados por el programador. Una vez introducidos los comentarios, el programa javadoc.exe (incluido en el JDK) genera de forma automática la información de forma
similar a la presentada en la propia documentación del JDK. La sintaxis de estos comentarios y la forma de utilizar el programa javadoc.exe se puede encontrar en la información que viene con el JDK.

Bifurcaciones

Las bifurcaciones permiten ejecutar una de entre varias acciones en función del valor de una expresión lógica o relacional. Se tratan de estructuras muy importantes ya que son las encargadas de controlar el flujo de ejecución de un programa. Existen dos bifurcaciones diferentes: if y switch.

Bifurcación if

Esta estructura permite ejecutar un conjunto de sentencias en función del valor que tenga la expresión de comparación (se ejecuta si la expresión de comparación tiene valor true). Tiene la forma siguiente:

if (booleanExpression) {
statements;
}

Las llaves {} sirven para agrupar en un bloque las sentencias que se han de ejecutar, y no son necesarias si sólo hay una sentencia dentro del if.

Bifurcación if else

Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas en el else se ejecutan en el caso de no cumplirse la expresión de comparación (false),

if (booleanExpression) {
statements1;
} else {
statements2;
}

Bifurcación if elseif else

Permite introducir más de una expresión de comparación. Si la primera condición no se cumple, se compara la segunda y así sucesivamente. En el caso de que no se cumpla ninguna de las comparaciones se ejecutan las sentencias correspondientes al else.

if (booleanExpression1) {
statements1;
} else if (booleanExpression2) {
statements2;
} else if (booleanExpression3) {
statements3;
} else {
statements4;
}

Véase a continuación el siguiente ejemplo:

int numero = 61;
// La variable "numero" tiene dos dígitos
if(Math.abs(numero) < 10)
// Math.abs() calcula el valor absoluto. (false)
System.out.println("Numero tiene 1 digito ");
else if (Math.abs(numero) < 100) // Si numero es 61, estamos en este caso (true)
System.out.println("Numero tiene 1 digito ");
else {
// Resto de los casos
System.out.println("Numero tiene mas de 3 digitos ");
System.out.println("Se ha ejecutado la opcion por defecto ");
}

Sentencia switch

Se trata de una alternativa a la bifurcación if elseif else cuando se compara la misma expresión con distintos valores. Su forma general es la siguiente:

switch (expression) {
case value1: statements1; break;
case value2: statements2; break;
case value3: statements3; break;
case value4: statements4; break;
case value5: statements5; break;
case value6: statements6; break;
default: statements7;
}

Las características más relevantes de switch son las siguientes:

1. Cada sentencia case se corresponde con un único valor de expression. No se pueden establecer rangos o condiciones sino que se debe comparar con valores concretos. El ejemplo del Apartado 2.3.3.3 no se podría realizar utilizando switch.

2. Los valores no comprendidos en ninguna sentencia case se pueden gestionar en default, que es
opcional.

3. En ausencia de break, cuando se ejecuta una sentencia case se ejecutan también todas las case que van a continuación, hasta que se llega a un break o hasta que se termina el switch.

Ejemplo:

char c = (char)(Math.random()*26+'a'); // Generación aleatoria de letras minúsculas
System.out.println("La letra " + c );
switch (c) {
case 'a': // Se compara con la letra a
case 'e': // Se compara con la letra e
case 'i': // Se compara con la letra i
case 'o': // Se compara con la letra o
case 'u': // Se compara con la letra u
System.out.println(" Es una vocal "); break;
default:
System.out.println(" Es una consonante ");
}

Bucles

Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina también lazo o loop. El código incluido entre las llaves {} (opcionales si el proceso repetitivo consta de una sola línea), se ejecutará mientras se cumpla unas determinadas condiciones. Hay que prestar especial atención a los bucles infinitos, hecho que ocurre cuando la condición de finalizar el bucle (booleanExpression) no se llega a cumplir nunca. Se trata de un fallo muy típico, habitual sobre todo entre programadores poco experimentados.

Bucle while

Las sentencias statements se ejecutan mientras booleanExpression sea true.

while (booleanExpression) {
statements;
}

Bucle for

La forma general del bucle for es la siguiente:
for (initialization; booleanExpression; increment) {
statements;
}

que es equivalente a utilizar while en la siguiente forma,

initialization;
while (booleanExpression) {
statements;
increment;
}
La sentencia o sentencias initialization se ejecuta al comienzo del for, e increment después de statements. La booleanExpression se evalúa al comienzo de cada iteración; el bucle termina cuando la expresión de comparación toma el valor false. Cualquiera de las tres partes puede estar vacía. La initialization y el increment pueden tener varias expresiones separadas por comas. Por ejemplo, el código situado a la izquierda produce la salida que aparece a la derecha:

Código:

for(int i = 1, j = i + 10; i < 5; i++, j = 2*i) {
System.out.println(" i = " + i + " j = " + j);
}
Salida:

i = 1 j = 11
i = 2 j = 4
i = 3 j = 6
i = 4 j = 8

Bucle do while

Es similar al bucle while pero con la particularidad de que el control está al final del bucle (lo que hace que el bucle se ejecute al menos una vez, independientemente de que la condición se cumpla o no). Una vez ejecutados los statements, se evalúa la condición: si resulta true se vuelven a ejecutar las sentencias incluidas en el bucle, mientras que si la condición se evalúa a false finaliza el bucle.

Este tipo de bucles se utiliza con frecuencia para controlar la satisfacción de una determinada condición de error o de convergencia.

do {
statements
} while (booleanExpression);

Sentencias break y continue

La sentencia break es válida tanto para las bifurcaciones como para los bucles. Hace que se salga inmediatamente del bucle o bloque que se está ejecutando, sin sin realizar la ejecución del resto de las sentencias.

La sentencia continue se utiliza en los bucles (no en bifurcaciones). Finaliza la iteración “i” que en ese momento se está ejecutando (no ejecuta el resto de sentencias que hubiera hasta el final del bucle). Vuelve al comienzo del bucle y comienza la siguiente iteración (i+1).

Sentencias break y continue con etiquetas

Las etiquetas permiten indicar un lugar donde continuar la ejecución de un programa después de un break o continue. El único lugar donde se pueden incluir etiquetas es justo delante de un bloque de código entre llaves {} (if, switch, do...while, while, for) y sólo se deben utilizar cuando se tiene uno o más bucles (o bloques) dentro de otro bucle y se desea salir (break) o continuar con la siguiente
iteración (continue) de un bucle que no es el actual.

Por tanto, la sentencia break labelName finaliza el bloque que se encuentre a continuación de labelName. Por ejemplo, en las sentencias,

bucleI: // etiqueta o label

for ( int i = 0, j = 0; i < 100; i++){
while ( true ) {
if( (++j) > 5) { break bucleI; } // Finaliza ambos bucles
else { break; } // Finaliza el bucle interior (while)
}
}
La expresión break bucleI; finaliza los dos bucles simultáneamente, mientras que la expresión break; sale del bucle while interior y seguiría con el bucle for en i. Con los valores presentados ambos bucles finalizarán con i = 5 y j = 6 (se invita al lector a comprobarlo).
La sentencia continue (siempre dentro de al menos un bucle) permite transferir el control a un bucle con nombre o etiqueta. Por ejemplo, la sentencia,
continue bucle1;
transfiere el control al bucle for que comienza después de la etiqueta bucle1: para que realice una nueva iteración, como por ejemplo:
bucle1:
for (int i=0; ibucle2:
for (int j=0; j...
if (expression) continue bucle1; then continue bucle2;
...
}
}

Sentencia return

Otra forma de salir de un bucle (y de un método) es utilizar la sentencia return. A diferencia de continue o break, la sentencia return sale también del método o función. En el caso de que la función devuelva alguna variable, este valor se deberá poner a continuación del return (return value; ).

Bloque try {...} catch {...} finally {...}

Java incorpora en el propio lenguaje la gestión de errores. El mejor momento para detectar los errores es durante la compilación. Sin embargo prácticamente sólo los errores de sintaxis son detectados en esta operación. El resto de problemas surgen durante la ejecución de los programas.

En el lenguaje Java, una Exception es un cierto tipo de error o una condición anormal que se ha producido durante la ejecución de un programa. Algunas excepciones son fatales y provocan que se deba finalizar la ejecución del programa. En este caso conviene terminar ordenadamente y dar un mensaje explicando el tipo de error que se ha producido. Otras excepciones, como por ejemplo no
encontrar un fichero en el que hay que leer o escribir algo, pueden ser recuperables. En este caso el programa debe dar al usuario la oportunidad de corregir el error (definiendo por ejemplo un nuevo path del fichero no encontrado).

Los errores se representan mediante clases derivadas de la clase Throwable, pero los que tiene que chequear un programador derivan de Exception (java.lang.Exception que a su vez deriva de Throwable). Existen algunos tipos de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el uso de bloques try, catch y finally.

El código dentro del bloque try está “vigilado”. Si se produce una situación anormal y se lanza como consecuencia una excepción, el control pasa al bloque catch, que se hace cargo de la situación y decide lo que hay que hacer. Se pueden incluir tantos bloques catch como se desee, cada uno de los cuales tratará un tipo de excepción. Finalmente, si está presente, se ejecuta el bloque finally, que es opcional, pero que en caso de existir se ejecuta siempre, sea cual sea el tipo de error.

En el caso en que el código de un método pueda generar una Exception y no se desee incluir en dicho método la gestión del error (es decir los bucles try/catch correspondientes), es necesario que el método pase la Exception al método desde el que ha sido llamado. Esto se consigue mediante la adición de la palabra throws seguida del nombre de la Exception concreta, después de la lista de argumentos del método. A su vez el método superior deberá incluir los bloques try/catch o volver a pasar la Exception. De esta forma se puede ir pasando la Exception de un método a otro hasta llegar al último método del programa, el método main().

En el siguiente ejemplo se presentan dos métodos que deben "controlar" una IOException relacionada con la lectura ficheros y una MyException propia. El primero de ellos (metodo1) realiza la gestión de las excepciones y el segundo (metodo2) las pasa al siguiente método:

void metodo1() {
...
try {
... // Código que puede lanzar las excepciones IOException y MyException
} catch (IOException e1) {// Se ocupa de IOException simplemente dando aviso
System.out.println(e1.getMessage());
} catch (MyException e2) {
// Se ocupa de MyException dando un aviso y finalizando la función
System.out.println(e2.getMessage()); return;
} finally {
// Sentencias que se ejecutarán en cualquier caso
...
}]
...
}
// Fin del metodo1

void metodo2() throws IOException, MyException {
...
// Código que puede lanzar las excepciones IOException y MyException
...
} // Fin del metodo2

Fuente: http://multiprogrammers.foroactivo.com/

Operadores en Java

2011-12-07T16:43:00.000-08:00

Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se describen brevemente en los apartados siguientes.

Operadores aritméticos

Son operadores binarios (requieren siempre dos operando) que realizan las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la división (%).

Operadores de asignación

Los operadores de asignación permiten asignar un valor a una variable. El operador de asignación por excelencia es el operador igual (=). La forma general de las sentencias de asignación con este operador es:

Operador  Utilización  Expresión equivalente
+=        op1 += op2   op1 = op1 + op2
-=        op1 -= op2   op1 = op1 – op2
*=        op1 *= op2   op1 = op1 * op2
/=        op1 /= op2   op1 = op1 / op2
%=        op1 %= op2   op1 = op1 % op2

variable = expression;

Tabla 2.2. Otros operadores de asignación.

Java dispone de otros operadores de asignación. Se trata de versiones abreviadas del operador (=) que realizan operaciones “acumulativas” sobre una variable. La Tabla 2.2 muestra estos operadores y su equivalencia con el uso del operador igual (=).

Operadores unarios

Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable, constante o expresión numérica. Su uso en Java es el estándar de estos operadores.

Operador instanceof

El operador instanceof permite saber si un objeto pertenece o no a una determinada clase. Es un operador binario cuya forma general es, objectName instanceof ClassName y que devuelve true o false según el objeto pertenezca o no a la clase.

Operador condicional ?:

Este operador, tomado de C/C++, permite realizar bifurcaciones condicionales sencillas. Su forma general es la siguiente:

booleanExpression ? res1 : res2

Donde se evalúa booleanExpression y se devuelve res1 si el resultado es true y res2 si el resultado es false. Es el único operador ternario (tres argumentos) de Java. Como todo operador que devuelve un valor puede ser utilizado en una expresión. Por ejemplo las sentencias:

x=1 ; y=10; z = ( x < y ) ? x+3:y+8;

asignarían a z el valor 4, es decir x+3.

Operadores incrementales

Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos operadores se pueden utilizar de dos formas:

1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y luego se utiliza (ya incrementada) en la expresión en la que aparece.

2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la expresión (con el valor anterior) y luego se incrementa.

En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos
operadores.

Operadores relacionales

Los operadores relacionales sirven para realizar comparaciones de igualdad, desigualdad y relación de menor o mayor. El resultado de estos operadores es siempre un valor boolean (true o false) según se cumpla o no la relación considerada.

La Tabla 2.3 muestra los operadores relacionales de Java.

Operador  Utilización    El resultado es true
>         op1 > op2      si op1 es mayor que op2
>=        op1 >= op2     si op1 es mayor o igual que op2
<         op1 < op2      si op1 es menor que op2
<=        op1 <= op2     si op1 es menor o igual que op2
==        op1 == op2     si op1 y op2 son iguales
!=        op1 != op2     si op1 y op2 son diferentes

Tabla 2.3. Operadores relacionales.

Operadores lógicos

Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores lógicos (true y/o false) o los resultados de los operadores relacionales. La Tabla 2.4 muestra los operadores lógicos de Java. Debe notarse que en ciertos casos el segundo operando no se evalúa porque ya no es necesario (si ambos tienen que ser true y el primero es false, ya se sabe que la condición de que ambos sean true no se va a cumplir). Esto puede traer resultados no deseados y por eso se han añadido los operadores (&) y (|) que garantizan que los dos operandos se evalúan siempre.

Operador  Nombre     Utilización   Resultado
&&        AND        op1 && op2    true si op1 y op2 son true. Si op1 es false ya no se evalúa op2
||        OR         op1 || op2    true si op1 u op2 son true. Si op1 es true ya no se evalúa op2.
!         negación   ! op          true si op es false y false si op es true
&         AND        op1 & op2     true si op1 y op2 son true. Siempre se evalúa op2
|         OR         op1 | op2     rue si op1 u op2 son true. Siempre se evalúa op2

Tabla 2.4. Operadores lógicos.

Operador de concatenación de cadenas de caracteres (+)

El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para escribir una cantidad con un rótulo y unas unidades puede utilizarse la sentencia:

System.out.println("El total asciende a " + result + " unidades");

Donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se desea imprimir por medio del método println(). La variable numérica result es convertida automáticamente por Java en cadena de caracteres para poderla concatenar. En otras ocasiones se deberá llamar explícitamente a un método para que realice esta conversión.

Precedencia de operadores

El orden en que se realizan las operaciones es fundamental para determinar el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un sentencia, de mayor a menor precedencia:

postfix operators  [] . (params) expr++ expr--
unary operators    ++expr --expr +expr -expr ~ !
creation or cast   new (type)expr
multiplicative     */%
additive           +-
shift              << >> >>>
relational         < > <= >= instanceof
equality           == !=
bitwise            AND &
bitwise            exclusive OR ^
bitwise            inclusive OR |
logical            AND &&
logical            OR ||
conditional        ?:
assignment         = += -= *= /= %= &= ^= |= <<= >>= >>>=

En Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que significa que el valor de la derecha se copia sobre la variable de la izquierda.

Fuente: http://multiprogrammers.foroactivo.com

Variables y Tipos de Datos en Java

2011-12-07T16:35:00.000-08:00

Las variables son las partes importantes de un lenguaje de programación: ellas son las entidades
(valores, datos) que actúan y sobre las que se actúa.
Una declaración de variable siempre contiene dos componentes, el tipo de la variable o de datos y su nombre.

tipoVariable nombreDeVariable;

Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser cualquier conjunto de caracteres numéricos y alfanuméricos, sin algunos caracteres especiales utilizados por Java como operadores o separadores ( ,.+-*/ etc.).

Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:

abstract
char
double
boolean
class
else
break
const*
extends
byte
case
catch
continue
default
do
final
finally
float
for
goto*
if
int
interface
long
package
static
throws
private
super
implements
protected
switch
transient
try
native
import
new
public
null
return
synchronized
void
instanceof
this
volatile
short
throw
while

(*) son palabras reservadas, pero no se utilizan en la actual implementación del lenguaje Java.

Todas las variables en el lenguaje Java deben tener un tipo de dato. Cuando hablamos de tipo de datos no referimos a los valores que la variable puede contener y las operaciones que se pueden realizar con ella.

Existen dos categorías de datos principales en el lenguaje Java: los tipos primitivos y los tipos referenciados.

Los tipos primitivos contienen un sólo valor e incluyen los tipos como los enteros (sin punto decimal), coma flotante (con punto decimal), los caracteres, etc.
La tabla siguiente muestra todos los tipos primitivos soportados por el lenguaje Java, su formato, su tamaño y una breve descripción de cada uno.

Tipo de variable	Descripción
Boolean	1 byte. Valores true y false
Char	2 bytes. Unicode. Comprende el código ASCII
Byte	1 byte. Valor entero entre -128 y 127
Short	2 bytes. Valor entero entre -32768 y 32767
Int	4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
Long	8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807
Float	4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45 y de 1.401298E-45 a 3.402823E38
Double	8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a -4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308

Los tipos primitivos de Java tienen algunas características importantes que se resumen a continuación:

1. El tipo boolean no es un valor numérico: sólo admite los valores true o false. El tipo boolean
no se identifica con el igual o distinto de cero, como en C/C++. El resultado de la expresión
lógica que aparece como condición en un bucle o en una bifurcación debe ser boolean.

2. El tipo char contiene caracteres en código UNICODE (que incluye el código ASCII), y ocupan
16 bits por carácter. Comprende los caracteres de prácticamente todos los idiomas.

3. Los tipos byte, short, int y long son números enteros que pueden ser positivos o negativos, con
distintos valores máximos y mínimos. A diferencia de C/C++, en Java no hay enteros unsigned.

4. Los tipos float y double son valores de punto flotante (números reales) con 6-7 y 15 cifras
decimales equivalentes, respectivamente.

5. Se utiliza la palabra void para indicar la ausencia de un tipo de variable determinado.

6. A diferencia de C/C++, los tipos de variables en Java están perfectamente definidos en todas y
cada una de las posibles plataformas. Por ejemplo, un int ocupa siempre la misma memoria y
tiene el mismo rango de valores, en cualquier tipo de ordenador.

7. Existen extensiones de Java 1.2 para aprovechar la arquitectura de los procesadores Intel, que
permiten realizar operaciones de punto flotente con una precisión extendida de 80 bits.
Cómo se definen e inicializan las variables.

Ejemplos de declaración e inicialización de variables

int x; // Declaración de la variable primitiva x. Se inicializa a 0
int y = 5; // Declaración de la variable primitiva y. Se inicializa a 5

MyClass unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa a null
unaRef = new MyClass(); // La referencia “apunta” al nuevo objeto creado
// Se ha utilizado el constructor por defecto

MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa al mismo valor que unaRef

int [] vector; // Declaración de un array. Se inicializa a null
vector = new int[10]; // Vector de 10 enteros, inicializados a 0

double [] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3
// elementos con los valores entre llaves

MyClass [] lista=new MyClass[5]; // Se crea un vector de 5 referencias a objetos
// Las 5 referencias son inicializadas a null

lista[0] = unaRef; // Se asigna a lista[0] el mismo valor que unaRef
lista[1] = new MyClass(); // Se asigna a lista[1] la referencia al nuevo objeto
// El resto (lista[2]...lista[4] siguen con valor null

En el ejemplo mostrado las referencias unaRef, segundaRef y lista[0] actuarán sobre el
mismo objeto. Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se
refieren es el mismo.

Visibilidad y vida de las variables

Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha variable es accesible y por lo tanto puede ser utilizada en una expresión. En Java todas las variables deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es decir, dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de cualquier método) son válidas mientras existe el objeto de la clase.

Las variables miembro de una clase declaradas como public son accesibles a través de una referencia a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen acceso a todas las variables miembro de A declaradas como public o protected, pero no a las declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y funciones miembro de su clase base declaradas como public o protected. Otra característica del lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada dentro del bloque oculta a la variable miembro en ese
bloque. Para acceder a la variable miembro oculta será preciso utilizar el operador this, en la forma this.varname.

Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la cual son creados y eliminados los objetos. En Java la forma de crear nuevos objetos es utilizando el operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta
de por cuántas variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el programa denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior significa que aunque una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras referencias apuntando a ese mismo objeto.

Fuente: http://multiprogrammers.foroactivo.com

Fedora 16 Verne Liberada!

2011-11-09T18:21:00.000-08:00

Saludos estimados lectores tengo para informarles que Fedora 16 de nombre "Verne" (En honor a el popular escritor Julio Verne) ha sido liberada el día de ayer, y como muchos sabemos fue liberada con Gnome 3.2 (Con Gnome Shell) y el Kernel 3.1, el cual viene con Xen integrado, más seguridad y mejor rendimiento, ademas de otras características interesantes como por ejemplo la Inclusión de Grub2, mayor integración con Systemd y se elimina totalmente Hal.

En este enlace pueden descargar todos sus formatos y spins.

Software libre ¿Público, social?

2011-10-30T18:50:00.000-07:00

Interesante entrevista realizada en Santo Domingo, Republica Dominicana en el programa "Ojalá" a Paola Miño del Ecuador, Octavio Rosell de Venezuela, Tatiana Al-Chueyr y Alexandre Oliva de Brasil, en la que cuentan los avances producidos por el Software Libre en sus respectivos países.

Visto en www.codigolibre.org

NIS: Guia de Instalación y Configuración en CentOS

2011-10-15T08:58:00.000-07:00

NIS (Network Information Services o anteriormente conocido como Sun Yellow Pages) es un servicio de directorios para la distribución y centralización de datos originalmente desarrollado por Sun Microsystems y actualmente disponible libremente en todas las distribuciones de Linux y variantes Unix.

Con NIS vamos a poder centralizar los nombres de usuarios, contraseñas de acceso, nombres de los equipos, entre otras cosas más en una infraestructura Unix.

NIS es comúnmente utilizado en conjunto con NFS, en esta guia solo nos basaremos en NIS, pero les dejare un ejemplo claro de las posiblidades de este duo dinamico (Luego escribire una guía sobre este ejemplo):

"Tenemos un servidor central corriendo NFS y NIS, con NFS se distribuye la partición /userdata y con NIS se distribuye la información de autentificación y resolucion de nombres. Los clientes estan configurados para autentificar a traves de NIS y tienen montada la partición /userdata, los usuarios del servidor NIS tienen su "home" en la partición /userdata, permitiendo que los datos de usuario y credenciales de acceso esten centralizadas en un servidor".

En esta guia estaré utilizando servidores CentOS, y empezamos con la instalación de los paquetes necesarios en el servidor:

# yum install ypbind yp-tools ypserv

Luego editamos el archivo /etc/yp.conf en donde agregamos la siguiente linea donde "punto-libre.org" es el dominio NIS y la IP mostrada es la IP del servidor:

domain punto-libre.org server 10.0.1.200

Luego editamos el archivo /etc/ypserv.conf dejandolo de esta manera:

dns: no #En caso de que no encuentre algun host en la tabla host, que no lo resuelva por DNS

files: 30 #Cantidad de mapas que se van a cachear, en 0 se deshabilita el cache

xfr_check_port: yes # Verifica que las solicitudes solo sean permitidas por puertos menores a 1024

#Se especifican los mapas que se van a servir, el * significa todo

#Host : Domain : Map : port

* : * : shadow.byname : port

* : * : passwd.adjunct.byname : port

* : * : hosts.byaddr : port

En la parte "Map" podemos especificar los mapass o el valor *, si queremos distribuir todas las tablas, en el ejemplo anterior estamos distribuyendo passwd, shadow y hosts.

En el siguiente paso es crear el archivo /var/yp/securenets, este especificara los hosts y redes que podran consultar nuestro servidor NIS, por ejemplo en caso de que sea la red 10.0.1.0/24 y nuestro mismo server tendria el siguiente contenido:

host 127.0.0.1

255.255.255.0 10.0.1.0

En caso de permitir cualquier red, con el siguiente contenido estaria bien:

0.0.0.0 0.0.0.0

Luego integramos nuestro servidor al dominio agregando al archivo /etc/sysconfig/network el siguiente parametro:

NISDOMAIN="punto-libre.org"

Luego ejecutamos los siguientes comandos:

# domainname punto-libre.org

# ypdomainname punto-libre.org

# hostname servidor.punto-libre.org

Despues creamos los mapas NIS, ejecutando el siguiente comando:

# /usr/lib/yp/ypinit -m

Y luego pulsando Control + D, luego Yes.

El nombre del servidor debe de estar resuelto, en caso de no tenerlo resuelto a traves de algun DNS, agregar al archivo /etc/hosts, algo parecido a esto:

10.0.1.200 server.opencop.net server opencop.net

Para terminar con el servidor subimos todos los servicios:

# service ypbind start && service yppasswdd start && service ypxfrd start && service portmap restart

Luego los ponemos en el arranque del sistema:

# chkconfig ypbind on && chkconfig yppasswd && chkconfig ypxfrd start && service portmap start

Cliente NIS:

Al cliente NIS le instalamos los siguientes paquetes:

# service ypbind yp-tools

Luego realizamos la misma configuración que en la parte servidora en los archivos /etc/yp.conf y /etc/hosts, y los comandos domainname y ypdomainname anteriormente vistos.

Editamos el archivo /etc/nsswitch.conf, agregandole "nis" de la siguiente manera:

passwd: file nis

shadow: file nis

group: file nis

Luego ponemos subimos el servicio ypbind y reiniciamos el portmap:

# service ypbind start && service portmap restart

Luego los ponemos en el arranque del sistema:

# chkconfig ypbind on && chkconfig portmap on

Finalmente con ypcat verificamos que estamos recibiendo lo que queremos (Solamente se recibiran los datos que no tengamos en el archivo passwd local):

# ypcat passwd

Y deberia mostrar:

carolina:!!:500:500::/userdata/carolina:/bin/bash

wilfredo:!!:502:502::/userdata/wilfredo:/bin/bash

alfredo:!!:501:501::/userdata/alfredo:/bin/bash

Y podremos acceder con esos usuarios... Luego veremos una guía donde integraremos NFS con NIS.

Iptables: Guia de Referencia

2011-10-14T20:52:00.000-07:00

Iptables es el componente más popular construido sobre Netfilter (Framework disponible en el núcleo Linux que permite interceptar y manipular paquetes de red), un sistema de Firewall que se ha extendido desde el kernel 2.4, a diferencia de otros Firewalls, este está integrado al Kernel, es parte del sistema operativo.

Esta guía pretende mostrarte los conceptos y las sintaxis de las reglas que vamos a poder aplicar a Iptables.

Anteriormente ya había escrito algunas guías que tienen algo que ver con Iptables pero a nivel de front-end con Shorewall:

-Implementando un firewall Básico con Shorewall
-Servidor VPN con OpenVPN y Shorewall

Para empezar debemos saber que un Firewall puede funcionar de dos modos:

A) Aceptando todo y denegando solo lo que se especifique.
B) Denegando todo y aceptando solo lo que se especifique.

Las reglas en Iptables se especifican en cadenas que están en tablas que se clasifican en dos tipos: filter & nat.

Las tablas tipo filter tienen las siguientes cadenas:

1) INPUT: Son los paquetes que van al Firewall (Que entran al firewall).
2) OUTPUT: Son los paquetes que son generados por el Firewall (Que salen del firewall)
3) FORWARD: Son los paquetes que son reenviados por el Firewall (Que vienen de un Host, pasan por el firewall, y van a otro Host o viceversa).

Las tablas tipo nat tienen las siguientes cadenas:

1) PREROUTING: La traducción de direcciónes ocurre antes de el enrutamiento.
2) POSTROUTING: La traducción de direcciones ocurre despues de el enrutamiento.

Antes de empezar a configurar Iptables lo recomendable es que limpiemos toda su configuración, ejecutando los siguientes comandos:

# iptables -F (Se borran las reglas de la tabla filter)
# iptables -t nat -F (Se borran las reglas de la tabla nat)
# iptables -Z (se reinician los contadores de paquetes)

Luego podemos guardar la configuración utilizando el script de inicio con la opcion save, por ejemplo:

# /etc/init.d/iptables save

Para mostrar todas las cadenas de la tabla filter podemos ejecutar uno de los siguientes comandos:

# iptables -t filter -L
# iptables -L (Ya que por defecto muestra las del tipo filter)

Y para mostrar todas las cadenas de la tabla nat lo especificamos así:

# iptables -t nat -L

Tambien podemos especificar una cadena especifica:

# iptables -L INPUT

Cada cadena tiene una politica por defecto que va a determinar el tipo de Firewall que estamos creando, esta politica la podemos definir con la opcion -P, guiandonos de la siguiente sintaxis:

# iptables -P CHAIN POLICY

Donde CHAIN es el nombre de la cadena (INPUT, OUTPUT, etc), y POLICY es la politica por defecto que puede ser ACCEPT (Acepta el paquete) o DROP (No acepta el paquete).

Si queremos que nuestro firewall deniegue todas las conecciones entrantes y acepte solo lo especificado, ejecutariamos el siguiente comando:

# iptables -P INPUT DROP

Si queremos que acepte todas las conecciones entrantes y deniegue solo lo especificado, ejecutariamos el siguiente comando:

# iptables -P INPUT ACCEPT

Si queremos que acepte todas las conecciones salientes y deniegue solo las especificadas, ejecutaríamos:

# iptables -P OUTPUT ACCEPT

Dado el caso de que tendriamos nuestro firewall configurado para que deniegue todas las conecciones entrantes y acepte todas las salientes, y quisieramos aceptar el trafico desde una IP especifica, podemos añadir una regla con las opciones: -A (Append), -s (Source), -j (Jump).

# iptables -A INPUT -s 10.0.1.10 -j ACCEPT

Si queremos aceptar el trafico desde una interfaz especifica agregamos la opcion -i (Inbound):

# iptables -A INPUT -i eth0 -j ACCEPT

Si queremos aceptar el trafico desde una interfaz e IP especifica (Combinamos las dos opciones):

# iptables -A INPUT -i eth0 -s 10.0.1.10 -j ACCEPT

Si quisiéramos ser más específicos y aceptar el trafico desde un protocolo, interfaz e IP especifica, le agregamos la opción -p para especificar el protocolo (tcp/udp) y luego la opción --dport para especificar un puerto destino:

# iptables -A INPUT -i eth0 -s 10.0.1.10 -p tcp --dport 22 -j ACCEPT

Si fuera desde una subred completa y un rango de puertos:

# iptables -A INPUT -i eth0 -s 10.0.1.0/24 -p tcp --dport 22:100 -j ACCEPT

Les dejo unos ejemplos más para terminar con las cadenas INPUT & OUTPUT:

# iptables -A INPUT -p tcp --dport 8080 -j DROP (Evitar acceso al puerto 8080 del Firewall)

# iptables -A OUTPUT -p tcp --dport 23 -j DROP (No permitir que salgan conexiones Telnet)

# iptables -A INPUT -p udp --dport 53 -j DROP (Evitar acceso al puerto UDP 53 del Firewall)

IP Forwarding:

El Kernel Linux tiene la capacidad de retransmitir o reenviar los paquetes que se reciben por una interfaz a otra interfaz utilizando el mecanismo "IP Forwarding", por lo tanto este mecanismo es necesario para poner a funcionar la cadena FORWARD.

Por defecto IP Forwarding no esta activado, para activarlo bastaría con ponerle un "1" al fichero /proc/sys/net/ipv4/ip_forward:

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

Pero para que el cambio se refleje al reiniciar la maquina es necesario que la opcion net.ipv4.ip_forward tenga un "1" en el fichero /etc/sysctl.conf.

Teniendo IP Forwarding habilitado y una politica por defecto de la cadena FORWARD en ACCEPT, podemos especificar servicios que no queremos que se reenvien, por ejemplo:

# iptables -A FORWARD -p tcp --dport 80 -j DROP
# iptables -A FORWARD -p udp --dport 53 -j DROP

Manipulación de Paquetes:

A traves de la tabla nat, iptables nos permite manipular los paquetes utilizando las siguientes cadenas:

PREROUTING:

Como mencionamos anteriormente con la cadena PREROUTING de la tabla NAT podemos manipular los paquetes antes del enrutamiento, esta la podemos usar cuando vallamos a realizar un DNAT (Destination Network Address Traslation): Tecnica para cambiar de forma transparente el destino de un paquete.

Aclaremos su funcionamiento con un breve ejemplo en Iptables, si por ejemplo quisieramos cambiar el destino de los paquetes de una maquina que entren por el puerto tcp 22 del firewall iptables a el puerto 3000 de otro servidor:

# iptables -t nat -A PREROUTING -s 10.0.1.10 -p tcp --dport 22 -j DNAT --to-destination servidor2:3000

Como podemos ver estamos especificando primeramente que utilizaremos la tablat nat, agregando en la cadena PREROUTING una regla que define que los paquetes TCP 22 que vengan del host 10.0.1.10 sean transferidos al puerto 3000 del servidor2.

POSTROUTING:

Con la cadena POSTROUTING podemos manipular los paquetes exactamente antes de mandarlos a la red, en esta cadena realizamos un SNAT (Source Network Address Traslation): Tecnica para cambiar de forma transparente el origen de un paquete.

Su funcionamiento queda claro en los siguientes ejemplos:

#iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to 10.0.1.1

En el ejemplo anterior estamos cambiando la dirección de origen de los paquetes que salen por eth0 a 10.0.1.1.

#iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to 10.0.1.1-10.0.1.9

En el ejemplo anterior estamos cambiando la dirección de origen de los paquetes que salen por eth0 a un rango de direcciónes.

La forma mas común en donde se refleja el uso del SNAT es en la tecnica llamada enmascaramiento "MASQUERADING", utilizado para que el Firewall enmascare las IP de la red local con la IP con la que el accede a otras redes (Por ejemplo internet), en pocas palabras todas las peticiones desde la red local a otras redes seran vistas como si provienen del Firewall.

Podemos realizar un enmascaramiento guiandonos de este ejemplo:

# iptables -t nat -A POSTROUTING -s 10.0.1.0/24 -o eth0 -j MASQUERADE

En el ejemplo anterior enmascaramos los paquetes que provienen de la red 10.0.1.0/24, para que salgan por la interfaz eth0 con la IP del Firewall.

Para finalizar con esta guia de Iptables les mostrare un diagrama que explica el flujo de los paquetes en base a las tablas y cadenas de Iptables:

Convertir disco virtual formato .vdi a .vmdk o viceversa

2011-09-29T14:34:00.000-07:00

Hoy tuve que buscar la forma de convertir un disco duro virtual formato .vdi creado por Virtualbox a formato .vmdk para poder usarlo en Vmware, y aqui les dejo como lo pude hacer. Para realizar los comandos que les mostrare necesitaran tener instalado Qemu y Virtualbox.

Para convertir de .vdi a .vmdk primero tenemos que convertir el disco .vdi a formato .raw de la siguiente manera:

# vboxmanage internalcommands converttoraw disco.vdi disco.raw

Y luego convertir de formato .raw a formato .vmdk

# qemu-img convert -O vmdk disco.raw disco.vmdk

Y en unos minutos tendremos nuestro disco .vmdk, para hacer lo contrario debemos convertir el disco .vmdk a formato .bin de la siguiente manera:

# qemu-img convert disco.vmdk disco.bin

Y luego convertimos la imagen .bin a .vdi:

# vboxmanage convertdd disco.bin disco.vdi

Y en unos minutos tendremos nuestro disco .vdi.

Saludos!

Perl - Net::SMTP::TLS - Mandar correos via SMTP con TLS

2011-09-29T09:14:00.000-07:00

Hola Mundo!

Gracias a la necesidad de mandar notificaciónes de Nagios utilizando un servidor SMTP remoto busque la manera de crear un script que me permita tal tarea, y adivine quien me ayudo? PERL!

Gracias a Perl y el modulo Net::SMTP::TLS pude crear un script que me permitio mandar correos a un servidor SMTP remoto que requiera TLS y autentificación (Por ejemplo Gmail como en este caso).

Antes de darles algunos ejemplos del script para que lo adapten a sus necesidades les voy a mostrar como instalar el modulo Net::SMTP::TLS, lo primero es entrar al "cpan shell":

# perl -MCPAN -e shell

cpan shell -- CPAN exploration and modules installation (v1.9456)
Enter 'h' for help.
cpan[1]>

Luego instalamos el modulo:

cpan[1]> install Net::SMTP::TLS

Empezará a descargar el modulo, automáticamente lo instalará y estaremos listos para usarlo.

Abrimos un editor de textos y nos guiamos de este script de ejemplo:

====================================================

#!/usr/bin/perl -w

use Net::SMTP::TLS;

$destinatario=$ARGV[1];
$mensaje=$ARGV[2];

my $smtp = new Net::SMTP::TLS('smtp.gmail.com',
Hello => 'smtp.gmail.com',
Port => 587,
User => 'usuario@gmail.com',
Password=> 'Contraseña18');

$smtp->mail('usuario@gmail.com');
$smtp->to("$destinatario");
$smtp->data;
$smtp->datasend("To: $destinatario\n");
$smtp->datasend("From: usuario@gmail.com');
$smtp->datasend("\n");

$mailer->datasend("Subject: Este es el asunto\n");
$mailer->datasend("\n");
$mailer->datasend("$mensaje\n");
$mailer->dataend();
$mailer->quit;

======================================================

En el ejemplo anterior se puede ver como se carga el modulo Net::SMTP::TLS, y declaran dos variables, las cuales seran igual al primer y el segundo argumento, luego el script se autentificará con los datos pre-establecidos y mandara el correo.

Guardamos nuestro script, le damos permisos de ejecución "chmod +x script.pl", y lo utilizamos de la siguiente manera:

./script.pl probando@gmail.com "Este es un mensaje enviado desde Perl"

Y listo, luego les cuento como utilizar este script en las notificaciones de Nagios.

Saludos!

Systemd: Servicios y Runlevels en Fedora 15

2011-09-26T05:00:00.000-07:00

Un cambio no tan notable para los usuarios, pero si muy drástico para los administradores o usuarios avanzados es la implementación de Systemd para manejar los servicios y runlevels, por tal motivo se utliza el comando "systemctl" para manejar los servicios en vez "services".

Los Scripts de inicio que utiliza services se encuentran en /etc/init.d/ y los que usa systemctl se encuentran en /lib/systemd/system/.

La sintaxis de systemctl es "systemctl comando daemon.service" siendo comando:

start - Inicia el servicio
stop - Detiene el servicio
restart - Reinicia el servicio
reload - Recarga el servicio
status - Muestra el Status del servicio
enable - Habilita el inicio del servicio al iniciar el sistema
disable - Deshabilita el inicio del servicio al iniciar el sistema

Los runlevels ahora son denominados targets:

runlevel 0 ---poweroff.target
runlevel 1 ---rescue.target
runlevel 2,3,4 ---multi-user.target
runlevel 5 --- graphical.target
runlevel 6 ---reboot.target

Para cambiar al runlevel 1 ejecutamos el siguiente comando:

# systemctl isolate rescue.target

Ya el runlevel por defecto no se determina en inittab, sino con un enlace simbolico de la siguiente manera:

# ln -sf /lib/systemd/system/multi-user.target /etc/systemd/system/default.target

De esta manera estamos determinando que el runlevel 3 (multi-user.target) sea el runlevel por defecto (Sobre-escribiendo el default.target).

Asterisk: Configuración del VoiceMail

2011-09-21T06:59:00.000-07:00

Algo elemental en Asterisk y en cualquier central telefónica es la configuración de un correo de voz, por tal razón escribo esta pequeña guia que pretende ayudarte en el proceso de configuración de este con Asterisk.

El archivo principal para la configuración del correo de voz es voicemail.conf, podemos encontrar una configuración de ejemplo en la fuente de Asterisk, o podemos crear uno desde cero, como en este caso.

De ejemplo tenemos ya configuradas dos extensiones SIP, 1001 y 1002. Creamos nuestro archivo voicemail.conf en el directorio raiz de Asterisk (Normalmente /etc/asterisk), y vamos agregándole los siguientes parámetros:

==================Fichero voicemail.conf===================

[general]

;Formato en el cual se grabaran los mensajes

format=gsm|wav

;Remitente del correo que nos llegara con la notificación de que tenemos un voicemail

serveremail=asterisk@punto-libre.org

;Nombre del remitente del correo que nos llegara

fromstring=Asterisk

;Activamos que nos mande el voicemail junto con la notificación

attach=yes

;Formato en el cual se enviaran los voicemail por correo

attachfmt=gsm

;Numero de mensajes maximos que se almacenaran por casilla

maxmsg=50

;Numero de segundos que durará cada mensaje

maxsecs=180

;Numero de segundos que podra durar el mensaje personalizado de bienvenida

maxgreet=100

;Numero de milisegundos (1000ms=1segundo) que se podra adelantar un mensaje

skipms=5000

;Numero Maximo de silencio que se podrá durar antes de que termine la grabación

maxsilence=5

;Parametro que determina lo que se considera ruido, mientras mas bajo... mas sencible

silencethreshold=120

;Numero maximo de veces que podremos intentar un logueo

maxlogins=3

;Mover automaticamente los mensajes oídos a la carpeta de mensajes viejos

moveheard=yes

;Contexto de Voicemail por defecto para los usuarios

userscontext=default

;Permite que se pueda mandar un Voicemail desde el VoicemailMain

sendvoicemail=yes

;Declaramos un Contexto de Voicemail

[PuntoLibreVmail)

;Declaramos las casillas del contexto

;Sintaxis: Extension => Contraseñá, Nombre, Correo, Opciones

1001 => 1001, Ramphis Che, rche@prueba.net

1002 => 1002, Wilfredo Che, wche@prueba.net

==================Fichero voicemail.conf===================

Luego procedemos a editar el archivo sip.conf, y le ponemos a cada usuario el contexto de voicemail a usar y el idioma, por ejemplo:

==================Fichero sip.conf=======================

[1001]
type=friend
host=dynamic
username=1001

secret=1001
voicemail=PuntoLibreVmail
language=es

context=internal
dtmfmode=auto

[1002]
type=friend
host=dynamic
username=1002
secret=1002
voicemail=PuntoLibreVmail
language=es
context=internal

dtmfmode=auto

===================Fichero sip.conf======================

Luego editamos nuestro plan de marcado, editando el archivo extensions.conf de la siguiente manera:

==================Fichero extensions.conf===================

[internal]

exten => _10XX,1,Dial(SIP/${EXTEN},10)
exten => _10XX,n,Voicemail(${EXTEN}@voicemail)
include => voicemail

[voicemail]
exten => *99,1,Answer()
exten => *99,n,VoiceMailMain(${CALLERID(num)}@voicemail)
exten => *99,n,Hangup()

==================Fichero extensions.conf===================

De esta manera cuando se marque una extensión, esta va a timbrar por 10 segundos, y luego le pedira que deje un mensaje, y al marcar *99 se podrá entrar a el correo de voz, y le pedirá solamente la contraseña (Ya que se especifica el usuario automáticamente al poner la variable ${CALLERID(num)}).

Finalmente reiniciamos Asterisk y solo faltaría probar:

# service asterisk restart

Un mejor look para Bash

2011-09-16T07:00:00.000-07:00

Buenos dias Gente!!!!! Tenia un tiempo que no escribia por muchos compromisos, y bueno... aunque no terminan, me veo "forzado" a colaborar, no???

En fin, hoy les tengo algo muy interesante y es sobre bash.... Saben que como administradores, es bueno automatizar, y porque no... dar un mejor look a nuestra shell...

Este script tenemos que pegarlo en nuestro archivo ".bashrc" en nuestro home para descargar el script ir a este link.

Este script hara que nuestro shell se vea de esta forma...

Squid: Autentificación contra un Active Directory (NTLM)

2011-09-15T13:26:00.000-07:00

Saludos estimados lectores, un amigo hace unos días me consulto como configurar Squid de tal forma que autentifique con los usuarios de un Active Directory, hay varias formas de realizar esto, pero en esta guia vamos a utilizar la ayuda de Samba y Winbind.

Si no sabes lo que es Squid ni Samba, te recomiendo leer las siguientes guias basicas de mi autoria:

-Control de acceso por horario con Squid

-Samba básico en Fedora 14

Opcionales:

-Guia de Instalación y Configuración de Dansguardian

-Multifiltro de Contenidos con Dansguardian

La siguiente guía puede aplicarse a cualquier distribución, ya que es el mismo procedimiento. Pero en esta guia estoy utilizando CentOS, cualquier inconveniente que tengan en sus distribuciones, me las dejan saber.

Para esta guia tengo el siguiente escenario:

1) Tengo 1 Servidor Windows Server 2003, el cual tiene configurado Active Directory y DNS, su FQDN es adwin.punto-libre.org.

2) Tengo un servidor CentOS 5.6 con Squid 2.6.

Teniendo en cuenta esto vamos a proceder a instalar instalar Samba:

# yum install samba samba-common

Y luego editamos su archivo de configuración /etc/samba/smb.conf quedando de la siguiente forma (Tener en cuenta que deben adaptar el archivo a su escenario):

[global]

workgroup = punto-libre

password server = punto-libre.org

security = domain

idmap uid = 10000-20000

idmap gid = 10000-20000

winbind separator = /

winbind use default domain = true

netbios name = CentOS

passdb backend = tdbsam

winbind cachetime = 10

interfaces = 10.0.1.0/24 127.0.0.1/8 #Adaptar a su red

Luego reiniciamos el servicio samba y winbind:

# service smb restart

# service winbind restart

Registramos nuestro servidor (CentOS en mi caso) a el Active Directory del servidor Windows:

# net join -S adwin.punto-libre.org -U Administrator (Sustituyan adwin.punto-libre.org por el FQDN de su servidor con AD)

Si nos lanza "Joined domain" esta todo bien hasta el momento, el siguiente paso seria verificar que Winbind esta funcionando correctamente. Esto lo hacemos con el comando wbinfo de las siguientes maneras:

# wbinfo -t

Nos deberá imprimir "checking the trust secret via RPC calls succeeded".

# wbinfo -u

Nos deberá imprimir los usuarios que estan en el Active Directory del servidor Windows.

#wbinfo -g

Nos deberá imprimir los grupos que estan en el Active Directory del servidor Windows.

Si los 3 comandos anteriores nos lanzaron lo que esperábamos, es hora de proceder con el siguiente paso, el cual es configurar el Name Service Switch (nss), el cual es una librería que nos provee una interfaz para acceder a diferentes bases de datos de cuentas de usuario y claves.

Para asegurarnos de que tenemos la librería nss para winbind, verificamos que tenemos el archivo libnss_winbind.so.2.

Teniendo este archivo, editamos el archivo /etc/nsswitch.conf dejandolo de esta manera:

passwd: files winbind

group: files winbind

Luego borramos el archivo TDB /var/cache/samba/winbindd_idmap.tdb:

# rm -rf /var/cache/samba/winbindd_idmap.tdb

De esta manera forzamos a que se cree nuevamente el archivo TDB en caso de que este corrupto y no se actualice (Experiencia propia).

Reiniciamos los winbind:

# service winbind restart

Y comprobamos que esta funcionando correctamente el nss con los siguientes comandos:

# getent passwd

Nos deberá mostrar una lista parecida a la de el archivo passwd pero que contendra tanto los usuarios locales como los de el AD.

# getent group

Nos deberá mostrar una lista parecida a la de el archivo groups pero que contendrá tanto los grupos locales como los de el AD.

Configuración de Squid

Si todo hasta el momento ha salido bien podemos configurar Squid. Antes de continuar vamos a probar si es posible la autentificación, utilizando el siguiente comando (Obvio: Squid debe estar instalado):

# ntlm_auth --herlper-protocol=squid-2.5-basic --username=Administrator

Nos pedira la contraseña de Administrator y si todo sale bien nos imprimira "NT_STATUS_OK: Success (0x0)"

Luego debemos darle permisos a otras aplicaciones de utilizar las funcionalidades de Winbind, dandole los permisos correspondientes a un directorio con el siguiente comando:

# chmod -R 750 /var/lib/samba/winbindd_privileged

Ahora editamos el archivo de configuración de Squid /etc/squid/squid.conf, guiandonos de esta configuración de ejemplo:

#Autentificación

auth_param ntlm program /usr/bin/ntlm_auth --helper-protocol=squid-2.5-ntlmssp

auth_param ntlm children 30

auth_param basic program /usr/bin/ntlm_auth --helper-protocol=squid-2.5-basic

auth_param basic children 5

auth_param basic realm Squid proxy-caching web server

auth_param basic credentialsttl 2 hours

#Listas de Control

#Debemos crear un archivo que contendra los nombres de los usuarios que tendran permisos

#En este caso "allowed-ad-users"

acl adusers proxy_auth -i "/etc/squid/"allowed-ad-users"

#Acceso

http_access allow adusers (Se permite el acceso a los usuarios que esten en la lista)

http_access deny !adusers (Se niega el acceso a los usuarios que no esten en la lista)

Finalmente reiniciamos Squid, y lo ponemos a prueba:

# service squid restart

Me he certificado! - Comptia Linux+ Powered By LPI

2011-09-13T08:58:00.000-07:00

Muy buenos días amigos, el motivo de este articulo es para comunicarle que estoy muy contento por haber cumplido con la meta que me propuse hace unos meses al decidir lograr la certificación Comptia Linux+.

Comptia "Computing Technology Industry Association" es una organización sin fines de lucro fundada en el 1982 y que se dedica a la certificación de profesionales para la industria de tecnologias de información.

Entre sus certificaciónes (Network+, Security+, Project+, A+, etc) esta Linux+, la cual prueba los conocimientos de los sistemas operativos Linux, desde su instalación y uso, hasta las aplicaciones libres, de codigo abierto y sus licencias.

Para lograr la certificación se requieren dos examenes de 60 preguntas: LX0-101 y LX0-102, y se recomiendan las certificaciónes A+ y Network+.

Los examenes abarcan los siguientes temas:

LX0-101:

1) Arquitectura del Sistema (14%)
2) Instalación y manejo de paquetes (18%)
3) Comandos GNU y Unix (43%)
)4) Dispositivos, Sistemas de Archivos (25%)

Mas detallado

LX0-102:

1) Shells, Scripting y manejo de datos (17%)
2) Interfaz de usuarios y escritorios (8%)
3) Tareas Administrativas (20%)
4) Servicios Esenciales del sistema (17%)
5) Fundamentos de redes (23%)
5) Seguridad (15%)

Mas detallado

Otra cosa importante que cabe mencionar es que Comptia y el Linux Professional Institute (LPI) se unieron para ayudar a avanzar a los profesionales de Linux.

Comptia utilizara el nivel de certificación 1 de LPI para su certificación, osea que el programa le permitira a el candidato obtener al mismo tiempo el certificado CompTIA Linux+ y el LPIC-1.

Si están interesados en la certificación les recomiendo los siguientes materiales de estudio:

1) CompTIA Linux+ Complete Study Guide de RoderickW. Smith
2) Linux+ Certificatión Bible de Trevor Kay (Basado en la antigua version de el examen)
3) Beginning Unix de Joe Merlino, Craig Zimmerman, Jeremy C. Reed, y Paul Weinstein

Saludos!

Servidor de Correos Basico con Postfix/Dovecot

2011-09-12T13:15:00.000-07:00

En esta guía de implementación de un servidor de correos en GNU/Linux nuestra meta principal es conocer los conceptos y elementos necesarios para configurar de forma basica un servidor de correos, nos vamos a limitar a lo mas básico posible, de manera que podamos introducirnos en este tema de la forma mas facíl posible.

Antes de proceder con esta guia voy a recomendarles que lean y pongan en practica el articulo "Configuración Basica de Bind DNS en CentOS", ya que es de suma importancia para la correcta implementación de un servidor de correos.

1) Conceptualizando

Un Servidor de Correos es el Software encargado del transporte de correos electrónicos atraves de la red, cuando un usuario manda un correo desde su Cliente de Correo Electrónico o MUA "Mail User Agent", este es enviado a el MTA "Mail Transfer Agent", y este lo envia mediante el protocolo SMTP a los otros MTAs "Mail Transfer Agents", cuando el correo llego a el MTA del destinatario, este es enviado a su MDA "Mail Delivery Agent" y almacenado hasta que el destinatario desee recibirlo mediante el protocolo POP o IMAP.

Para esta guía vamos a utilizar Postfix como MTA, Dovecot como MDA, y Evolution como MUA (Puede ser cualquier otro).

Postfix es un servidor de correos de Software Libre que se encarga del enrutamiento y envio de nuestros correos electronicos (MTA), fue creado para ser una alternativa mas facíl y segura que Sendmail.

Dovecot es un servidor de correo de codigo abierto que se encarga de la entrega de nuestros correos electronicos (MDA), fue creado para ser abierto, ligero, rapido, facil y seguro.

SMTP "Simple Mail Transfer Protocol" es un protocolo basado en texto utilizado para el intercambio de mensajes de correos electrónicos entre computadoras.

POP "Post Office Protocol" es un protocolo utilizado para obtener los mensajes de correo electronico almacenados en un servidor de correos. Actualmente se utiliza la version 3, por tal razon podemos ver que se le denomina mas frecuentemente POP3, este esta diseñado para descargar todos los correos del servidor y poder verlos sin conección.

IMAP "Internet Message Access Protocol" es un protocolo utilizado para acceder a los mensajes almacenados en un servidor de correos directamente, fue diseñado como una moderna alternativa a POP.

2) Configuracion del DNS

Un aspecto muy importante que hay que tener en cuenta es que necesitamos que nuestro dominio este resuelto, en caso de que no lo este... guiandonos de el articulo "Configuración Basica de Bind DNS en CentOS", vamos a agregar un registro A y un registro MX a nuestra configuración de zona, quedando de la siguiente manera por dar un ejemplo:

$TTL 7D

@ IN SOA dns.puntolibre.org. hostmaster.puntolibre.org. (

2010112301 ;Serial

3H ;Refresh

2H ;Retry

15D ;Expire

2D ;Negative Cache TTL

)

@ IN NS dns.puntolibre.org.

@ IN MX 10 mail

@ IN TXT "Punto Libre DNS"

@ IN A 192.168.1.100

dns IN A 192.168.1.100

mail IN A 192.168.1.100

www IN A 192.168.1.100

router IN A 192.168.1.1

equipo2 IN A 192.168.1.2

equipo3 IN A 192.168.1.3

Luego reiniciamos nuestro servidor DNS y comprobamos que esta resolviendo correctamente.

3) Instalando los paquetes

Procedemos a instalar los paquetes correspondientes a Postfix y Dovecot:

# yum -y install postfix dovecot

4) Cambiar entre servidores de correo

Es probable que Sendmail este por defecto como servidor de correo en tu sistema, asi que vamos a tener que cambiar a Postfix, con el siguiente comando podemos lograrlo:

# alternatives --config mta

Luego podremos elegir a Postfix, escribiendo el numero de Postfix, paramos el servicio Sendmail y evitamos que arranque con el sistema, y hacemos todo lo contrario con Postfix:

# service sendmail stop

# service postfix start

# chkconfig sendmail off

# chkconfig postfix on

5) Configuración de Postfix

Los archivos de configuración principales de Postfix son master.cf y main.cf ubicados en /etc/postfix/, como nuestra configuración es basica, no vamos a tener que modificar el master.cf (Con lo que tiene por defecto es suficiente).

Editamos el archivo main.cf guiandonos de este ejemplo (Recuerden que en mi ejemplo el dominio es puntolibre.org:

# Nombre del sistema

myhostname = mail.puntolibre.com

# Dominio.

mydomain = puntolibre.com

myorigin = $mydomain

# Tenemos que definir que escuche por todas las interfaces, por defecto solo escucha por loopback

#inet_interfaces = localhost

inet_interfaces = all

#Definimos el destino

mydestination = $myhostname, $mydomain, localhost.localdomain, localhost

# Definimos las redes

mynetworks = 192.168.1.0/24, 127.0.0.0/8

# En caso de que se vallan a manejar mas dominios de correo, se deberan agregar aqui

relay_domains = $mydestination

6) Configuración de Dovecot

Procedemos a configurar nuestro servidor POP/IMAP, su archivo de configuración principal es /etc/dovecot.conf, en su parámetro protocols vamos a especificar los protocolos que se pondrán en funcionamiento, ejemplo:

protocols = imap imaps pop3 pop3s

7) Reinicio de los servicios

Procedemos a reiniciar los servicios Postfix y Dovecot:

# service postfix restart

# service dovecot restart

8) Configuración de Evolutión

El siguiente paso seria la configuración de nuestro Mail User Agent, en este caso Evolution. Aqui les dejo algunas capturas de pantalla que muestran como configurarlo:

Procedemos dandole click a Adelante

Escribimos nuestro nombre y dirección de correo

Elegimos como ejemplo POP, ponemos el nombre de nuestro servidor de correo, el usuario,
sin cifrado y el tipo de autentificación en "Contraseña"

Elegimos SMTP, ponemos el nombre de nuestro servidor, y dejamos
todo en blanco ya que no configuramos SMTP por autentificación

Le ponemos un nombre a la cuenta

Tengan en cuenta que el usuario que configuramos es nuestra cuenta en el sistema y su respectivo password, el cual nos los pedira al intentar recibir los correos.

Como pueden ver trate de ser lo mas basicó posible, y espero que esto les sirva como base para introducirse a la materia, pronto veremos guias más avanzadas.

Saludos!

Convertir imágenes a PDF o viceversa con Imagemagick

2011-09-11T09:22:00.000-07:00

Esta mañana me vi en la necesidad de convertir un grupo de imágenes a PDF al descargar todos los volúmenes de el cómic de "V for Vendetta" para leerlo en el Ebook Reader. Pude lograr el cometido gracias a ImageMagick, Software Libre para la creación, edición y composición de imágenes con un gran catalogo de formatos.

Con ImageMagick los limites a nivel de conversión de imágenes son pocos, pero nos vamos a limitar a cumplir nuestro cometido "Convertir un grupo de imagenes a PDF o viceversa".

Para lograr esto, nos dirigimos a la carpeta donde estarán las imágenes... estas deben estar ordenadas de tal forma de que el PDF se creé en orden (Normalmente al descargar un cómic que viene en imágenes ya estará ordenado).

Como ejemplo tendríamos las siguientes imágenes:

-Imagen1
-Imagen2
-Imagen3
-Imagen4

Para convertir las estas imágenes a PDF ejecutaríamos el siguiente comando:

$ convert Imagen* archivo.pdf

Para hacer lo contrario bastaría con:

$ convert archivo.pdf Imagen.jpg

ImageMagick se encarga de enumerar las imágenes dependiendo de la cantidad de paginas del PDF.

Regalito: Los 10 Volumenes de "V for Vendetta" en español y en PDF.

[DESCARGAR]

Trickle: Limitador de ancho de banda para Linux

2011-09-09T16:30:00.000-07:00

Trickle es una super herramienta que tenemos disponibles en Linux con la cual vamos a poder limitar el ancho de banda tanto de subida y bajada de nuestras aplicaciones tanto al ejecutarlas como a través de un demonio; Vamos mostrarles como usarlo para ejecutar directamente una aplicación y aplicarle el control de ancho de banda (Podemos instalarlo desde los repositorios con el nombre "trickle").

La sintaxis de Trickle es la siguiente:

$ trickle -d Download_Bandwidth -u Upload_Bandwidth Comando

Aquí algunos ejemplos:

a) Limitar el ancho de banda de descarga a 10kbps utilizado para la transferencia de un fichero utilizando ssh:

$ trickle -d 10 scp fichero.mp3 10.0.0.1:/home/puntolibre/musica/

b) Limitar el ancho de banda a 50kpbs de descarga de una actualización del sistema a traves de Yum:

$ trickle -d 50 yum update -y

c) Si queremos modificarle el ancho de banda permanente a una aplicacion grafica, como por ejemplo firefox, podemos ir al elemento en la edición del menú y agregarle los comandos trickle de la siguiente manera:

Click Para Ampliar

Calibre: Gestor de Ebooks Multiplataforma

2011-09-09T06:48:00.000-07:00

Hoy me vi en la necesidad de buscar una solución que me permita gestionar mis libros electrónicos de una manera facil e intuitiva y que me permita el manejo de mi lector electrónico, y encontré Calibre, el cual es la solución perfecta para quienes tengan lectores electrónicos o simplemente quieran tener su biblioteca virtual de libros bien organizada.

Calibre creará una biblioteca bien organizada (basandose en sus metadatos) de tus libros en el directorio que elijas, y nos los mostrara de una manera bien intuitiva, permitiéndonos realizar busquedas basadas en ciertos parametros como Autores, Idiomas, Formatos, Editoriales, Etiquetas, etc.

Ademas de organizarnos nuestros Ebooks, Calibre nos permitira editar sus metadatos (Autor, Titulo, Año, etc), abrir el libro en su visor adecuado, guardar una copia del libro en la ubicación deseada, descargar información de internet sobre el libro (Portada, Valoración, Descripción, etc), convertir los libros a formatos moviles s y la posibilidad de gestionar nuestros libros directamente desde nuestros lectores electronicos (en mi caso tengo un Kindle, y lo maneja perfectamente).

Otra cosa interesante que nos ofrece Calibre es la posibilidad de proveer un servidor de contenidos web, donde se podra acceder a nuestra biblioteca via Web, descargar los libros y obtener toda la información que se deseé (Puerto 8080), Excelente.

Es raro que Calibra no se encuentre en los repositorios de tu distribución pero de todas maneras no les recomiendo instalarlo por esa vía (Ya que probablemente este desactualizado), simplemente ejecuten este simple comando y se les instalara automáticamente:

# sudo python -c "import urllib2; exec urllib2.urlopen('http://status.calibre-ebook.com/linux_installer').read(); main()"

Calibre también esta disponible en Mac y Windows, pueden dirigirse a su seccion de descargas.

Click Para Ampliar

Como limitar el numero de procesadores a usar en Linux?

2011-09-03T11:13:00.000-07:00

Con tan solo pasarle un parámetro llamado maxcpus al Kernel podemos limitar el numero de procesadores a utilizar en nuestro sistema, realmente a esto yo no le veo mucha utilidad ni lo pongo en practica, pero según he leído algunos softwares comerciales te cobran licencia por CPU, y para estos casos, este parámetro puede llegar a ser útil.

Para pasarle este comando al kernel vamos a editar nuestro archivo /boot/grub/grub.conf (Es posible que se llame menu.lst o grub.cfg), el cual tendría esta configuración de ejemplo:

default=1
timeout=0
splashimage=(hd0,0)/grub/splash.xpm.gz
hiddenmenu

title Fedora (2.6.35.14-95.fc14.i686)
root (hd0,0)
kernel /vmlinuz-2.6.35.14-95.fc14.i686 ro root=UUID=1693837e-7654-4568-903a-fec08441a9ae rd_NO_LUKS rd_NO_LVM rd_NO_MD rd_NO_DM LANG=es_DO.UTF-8 KEYBOARDTYPE=pc KEYTABLE=us-acentos noiswmd rhgb quiet
initrd /initramfs-2.6.35.14-95.fc14.i686.img

Le agregamos el parametro en la linea kernel de la siguiente manera en caso de que queramos usar solamente un proceador:

kernel /vmlinuz-2.6.35.14-95.fc14.i686 ro root=UUID=1693837e-7654-4568-903a-fec08441a9ae rd_NO_LUKS rd_NO_LVM rd_NO_MD rd_NO_DM LANG=es_DO.UTF-8 KEYBOARDTYPE=pc KEYTABLE=us-acentos noiswmd rhgb quiet maxcpus=1

Guardamos el archivo, y reiniciamos... al subir veremos que solamente tenemos un procesador activo.

Que hacer si se me llena la Swap?

2011-09-02T06:58:00.000-07:00

Si nuestra memoria de intercambio o Swap se nos llena podemos realizar unos cuantos comandos para agregar mas memoria de intercambio, la manera mas cómoda de realizar esto es generar una imagen con dd y usarla como memoria de intercambio cuando la necesitemos.

Para crear la imagen con dd lo hacemos de la siguiente manera:

# dd if=/dev/zero of=/tmp/newswap bs=1024 count=5120000

Lo que se hizo con el comando dd de forma detallada fue generar una imagen de 5Gb utilizando el archivo especial /dev/zero, el cual es utilizado normalmente para generar un archivo limpio.

Luego formateamos el archivo generado como SWAP, con el siguiente comando:

# mkswap /tmp/newswap

Y finalmente activamos el fichero como swap:

# swapon /tmp/newswap

Hasta la proxima!

Invocar un editor de textos para ejecutar comandos

2011-08-31T05:29:00.000-07:00

Desde nuestra shell podemos invocar a un editor de textos para escribir los comandos que serán ejecutados en nuestro sistema, para ello realizamos la combinación de teclas Ctrl-X + E y veremos que se nos presentara nuestro editor de textos.

En el podemos copiar los comandos a ejecutar o simplemente escribirlos, luego al salir del editor de textos estos comandos serán ejecutados (No se requiere que sea guardado el archivo).

Esta combinación de teclas ejecutara el editor de textos especificado en la variable $EDITOR, así que en caso de que quieras utilizar un editor de textos en especifico, como por ejemplo "Vim", podemos ejecutar el siguiente comando:

# export EDITOR='vim'

Se abrira "Vim", cuando tengamos todos los comandos copiados, salimos con :q! y veremos como los comandos son ejecutados en el orden establecido.

Sabias que...? 29/08/11

2011-08-29T10:23:00.000-07:00

Podemos crear fácilmente una imagen ISO de nuestros discos con el comando dd y las siguientes opciones:

if= ruta del dispositivo
of= ruta donde se guardara el archivo

Un ejemplo ideal seria:

# dd if=/dev/cdrom of=/home/ramphis/Escritorio/Imagen.iso

Mas fácil de ahí... imposible!

Angry Ip Scanner: Sencillo y Rapido escaner IP Multiplataforma

2011-08-23T10:49:00.000-07:00

Angry IP Scanner es un sencillo y rápido escaner de IP y puertos multiplataforma, no es tan potente como Nmap como para sustituirlo pero podrá sernos útil para cuando queramos realizar un reporte, ya que nos permite exportar el resultado.

Entre los resultados que nos podrá mostrar están:

Direccion IP con icono representando su estado
Tiempo de respuesta
Nombre del host
Puertos abiertos
Detección de servidor web
Información NetBIOS
Puertos Filtrados
TTL

Click para Ampliar

Descarga e Información

Ultracopier: Gestor de copias de archivos

2011-08-18T04:31:00.000-07:00

Ultracopier es un excelente gestor de copias de archivos disponible para Windows, Mac y GNU/Linux, diseñado especialmente para copiar o mover archivos de gran tamaño y garantizar la integridad de los archivos a pesar de la rapidez con la cual realiza sus funciones.

Lo encontré buscando una alternativa a Teracopy y en el proceso encontré otro llamado MiniCopier (Tambien Multiplataforma), el cual es muy semejante a este, pero me quedé con Ultracopier (Es posible que Minicopier este en los repositorios).

Entre las características que ofrece Ultracopier están:

Facilidad de uso
Rapidez de operación
Multiplataforma
Personalizable
Total control de lo que se hace
Gestior de errores y colisiones

Para su descarga pueden dirigirse a la pagina oficial del proyecto: ultracopier-es.first-world.info.