Problema canon pixma iP1900 en Ubuntu 12.04

Soy nuevo usuario de Ubuntu 12.04 y al querer instalar mi impresora canon pixma iP1900 me di cuenta que Ubuntu no tiene el driver o paquete necesario incluido, por lo que tuve que buscar y la solución funcional es descargar cnijfilter-common e instalarlo, luego descargar el de la impresora scangearmp-common e instalarlo.

Aquí encontrarán los paquetes de impresoras canon que no se puedan usar en Ubuntu Precise y Oneiric porque han sido descontinuados.

En la web encontrarán las soluciones de ir a la página de canon y descargar de ahí los paquetes o agregar  el repositorio PPA del Canon Driver  y bajar los paquetes de la impresora que se quiera, pero ninguna funciona.

Usabilidad de sistemas operativos

Instalé por primera vez una versión de Ubuntu con Unity, he escuchado muchos malos comentarios y esto hizo que me pusiera a analizar la usabilidad del software, así que decidí probarlo por mí mismo.

Algunos linuxeros dicen que Ubuntu ya no sirve, que ya no es como antes, que ahora apesta y que no se puede hacer nada en él, que no se puede modificar el unity y que prefieren gnome. He escuchado diseñadores y comunicadores decir que les interesa cumplir lo más pronto posible con su trabajo, sus diseños, artículos, etc. y que el software que les ayude a ser más eficientes es mejor.

¿Quién tendrá la razón?

Primeras impresiones con Ubuntu 12.04

Todo cambio al inicio cuesta, sentí extraño unity puesto que nunca lo había usado, el manejo de ventanas es distinto al igual que la búsqueda de programas. Quisiera que tuviera los fondos de pantalla que maneja KDE, siento raro no tener una barra horizontal sin embargo después de usarlo dos días me voy acostumbrando y creo que me agrada su simpleza.

No tuve ningún problema de reconocimiento de hardware o que se me trabara algún programa como me pasa siempre con kubuntu, lo único es que es más pesado.

Usabilidad y funcionalidad

Algo básico es la estabilidad, de nada sirve un sistema con el mejor aspecto gráfico si se traba al instalar programas o peor si se traba solo. Considero que los linux le dan la sensación a la gente que está haciendo cosas importantes y diferentes a las que "los mortales" hacen y en Ubuntu 12.04 se pierde eso, ahora lo volvieron sumamente sencillo y adaptado a usarlo en TV y móviles, razón por la cual los linuxeros dicen que no les gusta pero ¿qué es más importante? ¿la facilidad de uso o la adaptabilidad del sistema?

Yo le doy el visto bueno, la idea me convence aunque siento que se parece bastante al Mac gráficamente, ¿Qué es más importante para ti? ¿ La usabilidad o adaptabilidad?

Distribuciones Más Populares 2009

Según DistroWatch las distribuciones de Linux más populares durante el 2009 fueron:




















Podemos ver que Ubuntu ha sido la más popular y usado por su fácilidad y sentido humano.
A mí en lo personal me gustan mucho Sabayon y Kubuntu, aunque las últimas distribuciones de kubuntu me dieron un sin fin de errores y lo cambié por sabayon y Ubuntu.
Espero que la versión 9.10 haya mejorado.

Permisos carpetas en Linux

Copie información desde la red a un ubuntu, cuando quise usar los archivos no pude porque no tenían propietario, para darle los permisos a la carpeta use el comando como super usuario:

# chmod ··· archivo con la ruta completa

donde ··· son los permisos del los usuarios, grupo, y el resto de usuarios, si colocas 777 todos podran abrir, ejecutar y modificar el archivo.

Para cambiar el usuario usamos el comando:

chown usuario directorio

Si queremos cambiar de dueño todo lo que está adentro sería

chown -R usuario directorio

Problema en efectos de ubuntu 9.04

Instalé Ubuntu 9.04 que quería formatear mi compu y me tope con que los efectos no funcionaban , cuando me iba a Sistema-> Preferencias -> Apariencia -> Efectos Visuales y le quería dar "Extra" para que me pusiera los efectos me sacaba el error “No se han podido activar los efectos del escritorio“ entonces busqué un poco y la solución es abrir el archivo compiz y cambiar lo siguiente:

sudo vi /usr/bin/compiz


Buscamos donde dice “# blacklist based on the pci ids” y anteponemos un “#” en todas las líneas hasta la línea que indica “unset T“, de la siguiente forma:


# blacklist based on the pci ids
# See http://wiki.compiz-fusion.org/Hardware/Blacklist for details
#T=" 1002:5954 1002:5854 1002:5955" # ati rs480
#T="$T 1002:4153" # ATI Rv350
#T="$T 8086:2982 8086:2992 8086:29a2 8086:2a02 8086:2a12" # intel 965
#T="$T 8086:2a02 " # Intel GM965
#T="$T 8086:3577 8086:2562 " # Intel 830MG, 845G (LP: #259385)
#BLACKLIST_PCIIDS="$T"
#unset T






Referencia: Yvoictra Blog

Skins y Wallpapers Ubuntu

Como estoy usando ubuntu me puse a buscar skins y wallpapers para ponerle una presentación más agradable, les dejo los sitios oficiales por si quieren descargar skins, wallpapers y temas de emerald:

www.gnome-look.org
www.kde-look.org

Kubuntu 9.04 tampoco me sirvió

Siempre me han gustado más distribuciones linux con kde que con gnome.

Al terminar el semestre pasado hice un relajo mi compu por los proyectos y quería usar kubuntu 8.10 porque tenía nuevo estilo gráfico, me gustó bastante pero después de la 5ta instalación y ver que no funcionaba tuve que cambiarme, al final puse un ubuntu, que nunca me tuvo muy contento.
Pensé en instalar Debian, Gos o fedora, pero cuando me enteré que ya había salido sabayon 4.1 lo instalé y me gustó bastante, no le noté muchos cambios al 3 pero sabayon siempre me ha gustado mucho.
El problema empezó cuando necesitaba instalar cosas de emergencia y en sabayon se tardaba horas en compilarse los paquetes de los programas, entonces tuve que cambiar, salío Kubuntu 9.04, lo descargué 2 días después del lanzamiento, lo probe y estaba mejorado del 8.10 , muy feliz lo instalé y ....
se quedaba trabado, lo instalé 3 veces!!! pero siempre se quedó trabado,
muy triste tuve que regresar a ubuntu e instalarle skins porque no me gusta la presentación que tiene.

La instalación la hice en una laptop dell Inspiron 1420, a ver hasta cuando se me hace poder usar kubuntu con kde 4.

Hibernate in a Web JSF Application

I found a really good tutorial for using Hibernate in Netbeans IDE with Java Server Faces JSF as the visual web pages.

In this tutorial, you use the NetBeans IDE to create and deploy a web application that displays data from a database. The web application uses the Hibernate framework as the persistence layer for retrieving and storing plain old Java objects (POJOs) to a relational database.

Hibernate is framework that provides tools for object relational mapping (ORM). The tutorial demonstrates how to add support for the Hibernate framework to the IDE and create the necessary Hibernate files. After creating the Java objects and configuring the application to use Hibernate, you add Visual Web JSF components to a web page to display the data.

You can go to the tutorial here.

Fechas importantes del día en consola de Linux

Encontré un comando que me causó bastante gracia, podemos ver en consola acontecimientos importantes del día con el comando:

 $ calendar 

Miren los acontecimientos de hoy 2 de Marzo:

Colas de Mensajes para linux

Las colas de mensajes, junto con los semáforos y la memoria compartida son los recursos compartidos que pone unix a disposición de los programas para que puedan intercambiarse información.

En c para unix se puede hacer que dos aplicaciones se envien mensajes, para ello se usa la cola de mensajes, en ella se envian los mensajes y en la otra aplicación se sacan en el orden en que entraron.
Se envian los mensajes clasificados en tipos, estos son enteros.

Les muestro dos aplicaciones que envían mensajes,

Aplicación 1
ej_cola1.c

#include 
#include
#include 
#include 

// obligatoriamente como primer campo un long para indicar un identificador del mensaje.
// Los siguientes campos son la información que se quiera transmitir en el
// mensaje. Cuando más adelante, en el código, hagamos un cast a
// (struct msgbuf *), todos los campos de datos los verá el sistema como
// un único (char *)

struct Mi_Tipo_Mensaje
{
 long Id_Mensaje;
 int Dato_Numerico;
 char Mensaje[10];
}Un_Mensaje;

int main(void)
{
 key_t Clave1;
 int Id_Cola_Mensajes;

 // Igual que en cualquier recurso compartido (memoria compartida, semaforos
 //  o colas) se obtien una clave a partir de un fichero existente cualquiera
 //  y de un entero cualquiera. Todos los procesos que quieran compartir este
 //  semaforo, deben usar el mismo fichero y el mismo entero.
 
 Clave1 = ftok ("/bin/ls", 33);
 if (Clave1 == (key_t)-1)
 {
  printf("Error al obtener clave para cola mensajes");
  return(0);
 }

 // Se crea la cola de mensajes y se obtiene un identificador para ella.
 // El IPC_CREAT indica que cree la cola de mensajes si no lo está.
 // el 0600 son permisos de lectura y escritura para el usuario que lance
 // los procesos. Es importante el 0 delante para que se interprete en octal.
 
 Id_Cola_Mensajes = msgget (Clave1, 0600 | IPC_CREAT);
 if (Id_Cola_Mensajes == -1)
 {
  printf("Error al obtener identificador para cola mensajes");
  return(0);
 }

 // Se rellenan los campos del mensaje que se quiere enviar.
 // El Id_Mensaje es un identificador del tipo de mensaje. Luego se podrá
 // recoger aquellos mensajes de tipo 1, de tipo 2, etc.
 // Dato_Numerico es un dato que se quiera pasar al otro proceso. Se pone,
 // por ejemplo 29.
 // Mensaje es un texto que se quiera pasar al otro proceso.
 
 Un_Mensaje.Id_Mensaje = 1;
 Un_Mensaje.Dato_Numerico = 29;
 strcpy (Un_Mensaje.Mensaje, "Hola");

 // Se envia el mensaje. Los parámetros son:
 // - Id de la cola de mensajes.
 // - Dirección al mensaje, convirtiéndola en puntero a (struct msgbuf *)
 // - Tamaño total de los campos de datos de nuestro mensaje, es decir
 // de Dato_Numerico y de Mensaje
 // - Unos flags. IPC_NOWAIT indica que si el mensaje no se puede enviar
 // (habitualmente porque la cola de mensajes esta llena), que no espere
 // y de un error. Si no se pone este flag, el programa queda bloqueado
 // hasta que se pueda enviar el mensaje.
 
 msgsnd (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
   sizeof(Un_Mensaje.Dato_Numerico)+sizeof(Un_Mensaje.Mensaje),
   IPC_NOWAIT);

 // Se recibe un mensaje del otro proceso. Los parámetros son:
 // - Id de la cola de mensajes.
 // - Dirección del sitio en el que queremos recibir el mensaje,
 // convirtiéndolo en puntero a (struct msgbuf *).
 // - Tamaño máximo de nuestros campos de datos.
 // - Identificador del tipo de mensaje que queremos recibir. En este caso
 // se quiere un mensaje de tipo 2. Si ponemos tipo 1, se extrae el mensaje
 // que se acaba de enviar en la llamada anterior a msgsnd().
 // - flags. En este caso se quiere que el programa quede bloqueado hasta
 // que llegue un mensaje de tipo 2. Si se pone IPC_NOWAIT, se devolvería
 // un error en caso de que no haya mensaje de tipo 2 y el programa
 // continuaría ejecutándose.
 
 msgrcv (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
   sizeof(Un_Mensaje.Dato_Numerico) + sizeof(Un_Mensaje.Mensaje),
   2, 0);

 printf("Recibido mensaje tipo 2 \n");
 printf("Dato_Numerico = %i \n",Un_Mensaje.Dato_Numerico);
 printf("Mensaje = %s \n",Un_Mensaje.Mensaje);

 
 // Se borra y cierra la cola de mensajes.
 // IPC_RMID indica que se quiere borrar. El puntero del final son datos
 // que se quieran pasar para otros comandos. IPC_RMID no necesita datos,
 // así que se pasa un puntero a NULL.
 
 msgctl (Id_Cola_Mensajes, IPC_RMID, (struct msqid_ds *)NULL);
}

Aplicación 1
ej_cola2.c

#include 
#include 
#include 
#include 

// Estructura para los mensajes que se quieren enviar y/o recibir. Deben llevar
// obligatoriamente como primer campo un long para indicar un identificador
// del mensaje.
// Los siguientes campos son la información que se quiera transmitir en el
// mensaje. Cuando más adelante, en el código, hagamos un cast a
// (struct msgbuf *), todos los campos de datos los verá el sistema como
// un único (char *)

struct Mi_Tipo_Mensaje
{
 long Id_Mensaje;
 int Dato_Numerico;
 char Mensaje[10];
}Un_Mensaje;


int main(void)
{
 key_t Clave1;
 int Id_Cola_Mensajes;

 // Igual que en cualquier recurso compartido (memoria compartida, semaforos
 //  o colas) se obtien una clave a partir de un fichero existente cualquiera
 //  y de un entero cualquiera. Todos los procesos que quieran compartir este
 //  semaforo, deben usar el mismo fichero y el mismo entero.
 
 Clave1 = ftok ("/bin/ls", 33);
 if (Clave1 == (key_t)-1)
 {
  printf("Error al obtener clave para cola mensajes \n");
  return(0);
 }

 // Se crea la cola de mensajes y se obtiene un identificador para ella.
 // El IPC_CREAT indica que cree la cola de mensajes si no lo está.
 // el 0600 son permisos de lectura y escritura para el usuario que lance
 // los procesos. Es importante el 0 delante para que se interprete en
 // octal.
 
 Id_Cola_Mensajes = msgget (Clave1, 0600 | IPC_CREAT);
 if (Id_Cola_Mensajes == -1)
 {
  printf("Error al obtener identificador para cola mensajes \n");
  return(0);
 }

 // Se recibe un mensaje del otro proceso. Los parámetros son:
 // - Id de la cola de mensajes.
 // - Dirección del sitio en el que queremos recibir el mensaje,
 // convirtiéndolo en puntero a (struct msgbuf *).
 // - Tamaño máximo de nuestros campos de datos.
 // - Identificador del tipo de mensaje que queremos recibir. En este caso
 // se quiere un mensaje de tipo 1, que es el que envia el proceso cola1.cc
 // - flags. En este caso se quiere que el programa quede bloqueado hasta
 // que llegue un mensaje de tipo 1. Si se pone IPC_NOWAIT, se devolvería
 // un error en caso de que no haya mensaje de tipo 1 y el programa
 // continuaría ejecutándose.
 
 msgrcv (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
   sizeof(Un_Mensaje.Dato_Numerico) + sizeof(Un_Mensaje.Mensaje),
   1, 0);

 printf("Recibido mensaje tipo 1 \n");
 printf("Dato_Numerico = %i \n",Un_Mensaje.Dato_Numerico);
 printf("Mensaje = %s \n",Un_Mensaje.Mensaje);

 // Se rellenan los campos del mensaje que se quiere enviar.
 // El Id_Mensaje es un identificador del tipo de mensaje. Luego se podrá
 // recoger aquellos mensajes de tipo 1, de tipo 2, etc.
 // Dato_Numerico es un dato que se quiera pasar al otro proceso. Se pone,
 // por ejemplo 13.
 // Mensaje es un texto que se quiera pasar al otro proceso.
 //
 Un_Mensaje.Id_Mensaje = 2;
 Un_Mensaje.Dato_Numerico = 13;
 strcpy (Un_Mensaje.Mensaje, "Adios");

 // Se envia el mensaje. Los parámetros son:
 // - Id de la cola de mensajes.
 // - Dirección al mensaje, convirtiéndola en puntero a (struct msgbuf *)
 // - Tamaño total de los campos de datos de nuestro mensaje, es decir
 // de Dato_Numerico y de Mensaje
 // - Unos flags. IPC_NOWAIT indica que si el mensaje no se puede enviar
 // (habitualmente porque la cola de mensajes esta llena), que no espere
 // y de un error. Si no se pone este flag, el programa queda bloqueado
 // hasta que se pueda enviar el mensaje.
 
 msgsnd (Id_Cola_Mensajes, (struct msgbuf *)&Un_Mensaje,
   sizeof(Un_Mensaje.Dato_Numerico)+sizeof(Un_Mensaje.Mensaje),
   IPC_NOWAIT);
}

Para correr los archivos .c se compilan en consola con:

# gcc  ej_sem1.c -o ej_sem1

Y para correrlo:

# ./ej_sem1

Lo mismo con el segundo archivo, se corre cada uno en una consola diferente y veremos como funcionan los semáforos del sistema operativo linux/unix.

Para mayor referencia:
http://www.chuidiang.com/clinux/ipcs/colas.php

Semáforos para Linux

A veces se tienen varios procesos que deben de usar un recurso compartido, pero si los dos usaran el recurso al mismo tiempo provocarían un problema.
Un semáforo da acceso al recurso a uno de los procesos y se lo niega a los demás mientras el primero no termine. Los semáforos, junto con la memoria compartida y las colas de mensajes, son los recursos compartidos que suministra UNIX para comunicación entre procesos.

Necesito usar semáforos pero que sean del sistema operativo Linux, para ello se usan semáforos desde c.
Pondré un ejemplo de dos procesos que se ejecutan usando los semáforos,


Archivo 1
ej_sem1.c

#include 
#include 
#include 
#include 
#include 

// Esta union hay que definirla o no según el valor de los defines aquí indicados.

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
// La union ya esta definida en sys/sem.h
#else
// Tenemos que definir la union
union semun
{
 int val;
 struct semid_ds *buf;
 unsigned short int *array;
 struct seminfo *__buf;
};
#endif

int main(void)
{
 key_t Clave;
 int Id_Semaforo;
 struct sembuf Operacion;
 union semun arg;
 int i=0;

   // Igual que en cualquier recurso compartido (memoria compartida, semaforos
   // o colas) se obtien una clave a partir de un fichero existente cualquiera
   // y de un entero cualquiera. Todos los procesos que quieran compartir este
   // semaforo, deben usar el mismo fichero y el mismo entero.
      
 Clave = ftok ("/bin/ls", 33);
 if (Clave == (key_t)-1)
 {
  printf("No puedo conseguir clave de semaforo\n");
  exit(0);
 }

 // Se obtiene un array de semaforos (10 en este caso, aunque solo se usara uno.
 // El IPC_CREAT indica que lo  cree si no lo está
 // el 0600 con permisos de lectura y escritura para el usuario que lance
 // los procesos. Es importante el 0 delante para que se interprete en
 // octal.
        
 Id_Semaforo = semget (Clave, 10, 0600 | IPC_CREAT);
 if (Id_Semaforo == -1)
 {
  printf("No puedo crear semaforo\n");
  exit (0);
 }

 // Se inicializa el semáforo con un valor conocido. Si lo ponemos a 0,
 // el semáforo estará "rojo". Si lo ponemos a 1, estará "verde".
 // El 0 de la función semctl es el índice del semáforo que queremos
 // inicializar dentro del array de 10 que hemos pedido.
 
 arg.val = 0;
 semctl (Id_Semaforo, 0, SETVAL, &arg);

 
 // Para "pasar" por el semáforo si está "rojo", debemos rellenar esta estructura.
 // sem_num es el indice del semáforo en el array por el que queremos "pasar"
 // sem_op es -1 para hacer que el proceso espere al semáforo.
 // sem_flg son flags de operación. De momento nos vale un 0.
 
 Operacion.sem_num = 0;
 Operacion.sem_op = -1;
 Operacion.sem_flg = 0;

 // Bucle infinito indicando cuando entramos al semáforo y cuándo salimos
 // de él.
 // i hace de contador del número de veces que hemos salido del semáforo.
 //
 while (1)
 {
  printf("%i Esperando semaforo\n",i );
  
           // Se hace la espera en el semáforo. Se le pasa un array de operaciones
  // y el número de elementos en dicho array. En nuestro caso solo 1.
  
  semop (Id_Semaforo, &Operacion, 1);
  printf("%i Salgo de Semaforo\n ",i);
  i++;
 }
}

Y adjunto el segundo archivo con el otro semáforo,

Archivo 2
ej_sem2.c

#include 
#include 
#include 
#include 
#include 
#include 

// Esta union hay que definirla o no según el valor de los defines aqui indicados.

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
// La union ya está definida en sys/sem.h
#else
// Tenemos que definir la union

union semun
{
 int val;
 struct semid_ds *buf;
 unsigned short int *array;
 struct seminfo *__buf;
};
#endif

int main(void)
{
 key_t Clave;
 int Id_Semaforo;
 struct sembuf Operacion;
 union semun arg;
 int i;

 // Igual que en cualquier recurso compartido (memoria compartida, semaforos
 // o colas) se obtien una clave a partir de un fichero existente cualquiera
 // y de un entero cualquiera. Todos los procesos que quieran compartir este
 //      semaforo, deben usar el mismo fichero y el mismo entero.
 
 Clave = ftok ("/bin/ls", 33);
 if (Clave == (key_t)-1)
 {
  printf("No puedo conseguir clave de semaforo\n");
  exit(0);
 }

 // Se obtiene un array de semaforos (10 en este caso, aunque solo se usara uno.
 // El IPC_CREAT indica que lo  cree si no lo esta
 // el 0600 con permisos de lectura y escritura para el usuario que lance
 // los procesos. Es importante el 0 delante para que se interprete en
 // octal.
  
 Id_Semaforo = semget (Clave, 10, 0600 | IPC_CREAT);
 if (Id_Semaforo == -1)
 {
  printf("No puedo crear semaforo\n");
  exit (0);
 }

 // Se levanta el semáforo. Para ello se prepara una estructura en la que
 // sem_num indica el indice del semaforo que queremos levantar en el array
 // de semaforos obtenido.
 // El 1 indica que se levanta el semaforo
 // El sem_flg son banderas para operaciones raras. Con un 0 vale.
 //
 Operacion.sem_num = 0;
 Operacion.sem_op = 1;
 Operacion.sem_flg = 0;

 // Vamos a levantar el semáforo 10 veces esperando 1 segundo cada vez.
 
 for (i = 0; i<10;>

Para correr los archivos .c se compilan en consola con:

# gcc  ej_sem1.c -o ej_sem1

Y para correrlo:

# ./ej_sem1

Lo mismo con el segundo archivo, se corre cada uno en una consola diferente y veremos como funcionan los semáforos del sistema operativo linux/unix.

Para mayor referencia visiten este sitio:
http://www.chuidiang.com/clinux/ipcs/semaforo.php

Detectar Enter en QLineEdit de QT

Estoy usando un QLineEdit para ingresar texto, puse un botón de Ingreso para aceptar el texto del QLineEdit, quería hacer lo mismo pero al presionar enter, para esto solo se debe de usar el evento returnPressed() en un slot sobre el QLineEdit y cada vez que se presiona enter al estar el puntero sobre él accionará el evento.

Borrar carpetas en linux

He necesitado borrar archivos de virus desde linux en las usb y algúnos no se pueden borrar sin permiso.

Para borrarlos entramos como super usuario:

#su

Para borrar archivos:

#rm nombre_archivo

Para borrar directorios vacíos:

#rmdir nombre_carpeta

Para borrar directorios con los archivos que inclue:

#rm -r nombre_carpeta

Escritorio remoto vnc en Ubuntu

La configuración de escritorio remoto por vnc en ubuntu (linux) es realmente sencilla, iré detallando los pasos con screens, usé ubuntu 7.10 para las pruebas.

En el host al que se quiere accesar remotamente hay que darle permisos de acceso remoto, nos vamos a sistema -> preferencias -> escritorio remoto, y le damos permiso, también podemos poner una contraseña para poder ingresar.



Desde el host que usaremos para ingresar al host servidor de vnc debemos de instalar Krdc, software de kde que nos hace el acceso remoto, lo podemos instalar en synaptic.


Ingresamos a la aplicación de krdc, el host al que queremos ingresar ya debe de estar en la misma red y con el permiso de acceso habilitado. Se nos muestra una lista de hosts a los que podemos accesar remotamente, seleccionamos uno y le damos connect, nos podemos dar cuenta que usa el puerto 5900


Nos hace preguntas sobre el tipo de conexión y contraseñas

En el host al que queremos ingresar remotamente nos pide permiso para poder acceder, le decimos que si para que se pueda entrar


Y ya estamos en el sistema operativo remotamente, podemos hacer de todo.....

Openssh en Ubuntu

OpenSSH es una versión libre del protocolo Secure Shell (SSH) que es una familia de herramientas para control remoto o transferencia de ficheros entre ordenadores. Las herramientas utilizadas para realizar estas funciones, eran el telnet o el rcp, que son inseguras y transmiten el password de los usuarios en texto plano cuando son usadas. OpenSSH provee un demonio y clientes para facilitar un seguro y encriptado control remoto y operaciones de transferencia de fichero, reemplaza efectivamente las herramientas heredadas.

El componente servidor OpenSSH , sshd, escucha continuamente a la espera de conexiones de clientes desde cualquiera de las herramientas cliente. Cuando aparece una petición conexión, sshd establece la conexión correcta dependiendo del tipo de herramienta cliente que está conectándose. Por ejemplo, si el equipo remoto se está conectando con la aplicación cliente ssh, el servidor OpenSSH establecerá una sesión de control remoto tras la autenticación. Si el usuario remoto se conecta al servidor OpenSSH con scp, el demonio del servidor OpenSSH iniciará una copia segura de archivos entre el servidor y el cliente tras la autenticación. OpenSSH puede usar muchos métodos de autenticación, incluyendo contraseñas planas, claves públicas y tickets de Kerberos

Instalación

Instalamos el cliente desde consola

#sudo apt-get install openssh-client

instalamos el servidor

#sudo apt-get install openssh-server  

reiniciamos el servidor de ssh

#sudo /etc/init.d/ssh restart

Usar el cliente SSH

Asumiendo que el nombre del host es userver.mydomain.com entonces pondríamos el siguiente comando:

# ssh vivek@userver.mydomain.com

Si nos queremos conectar con la ip también lo podemos hacer:
# ssh 192.168.0.3

Para parar el servidor ssh ponemos:
# sudo /etc/init.d/ssh stop

Para iniciar el servidor ssh:
# sudo /etc/init.d/ssh start
Para reiniciar el servidor ssh:
# sudo /etc/init.d/ssh restart


Referencias:

http://doc.ubuntu-es.org/Servidor_OpenSSH
http://www.cyberciti.biz/faq/ubuntu-linux-openssh-server-installation-and-configuration/
https://help.ubuntu.com/ubuntu/serverguide/es/openssh-server.html

Efectos de compiz fusion en linux

Les dejo un video de la presentación de los efectos gráficos de compiz fusion en el evento Ubucon, un evento de conferencias de ubuntu (distribución de linux)....

Mejoras en ubuntu 8.04

Siempre me preguntan que cuales son las mejoras con las nuevas versiones de linux. Me han preguntado muchas veces que ahora que le mejoraron al ubuntu 8.04-Hardy Heron, preferí investigar y escribir en mi blog cuales son las mejoras. Las tomé de Noticias Tech, y las adjunto al post para que las lean.

Incorporación del navegador Mozilla Firefox 3, en su versión beta 2.

Integración de aplicaciones con PolicyKit (permite establecer un sistema de privilegios. Es decir el administrador puede autorizar que un usuario normal realice algunas acciones o tareas ignorando el requerimiento de privilegios, lo que elevará la seguridad del sistema), y reemplaza a gksu para administras y usar las prerrogativas de usuario administrador.

Xorg 7.3, la versión 7.3 de la implementación de código abierto del sistema X Window System.

Linux Kernel 2.6.24. Esto es lo que nos encontramos en la nuevo Kernel:

* Mejoras del gestor de procesos: Se podrá configurar cómo particionar el tiempo de CPU entre usuarios o grupos.

* Task Control Groups, o grupos de control de procesos: Sirve para asignar y controlar los recursos a grupos de procesos. La idea es que el usuario crea “grupos de control de procesos”, algo que en la práctica consiste crear uno o varios directorios en un sistema de archivos virtual especial. Ese directorio contiene, nada más crearle, un monton de archivos que pone ahí el kernel y que son la interfaz de configuración. Leyendo o escribiendo a esos archivos uno configura las propiedades del grupo creado.

* Soporte de Tickless: Una nueva infraestructura para gestionar el tiempo muerto de la CPU.

* Reunificación de las fuentes de x86-32 y x86-64: Ya no hay arch/i386 y arch/x86_64, hay un solo directorio arch/x86 (aunque se conservan algunos enlaces simbólicos en los directorios antiguos, por compatibilidad).

* Puntos de montaje “bind” de solo lectura: -bind sirve para montar un directorio o punto de montaje ya existente en cualquier otro lado.

* Espacios de nombres para los PIDs y la pila de red: Esto tiene que ver con la virtualización a nivel de sistema operativo, tipo vServer o OpenVZ, las “jails” de los BSDs o los Containers de Solaris.

* Límites de memoria “sucia” para cada dispositivo: Los límites de la cantidad de memoria que puede estar “sucia” (sin escribir a disco) son independientes para cada dispositivo y se calculan dinámicamente.

* Soporte SPI/SDIO en la capa MMC: de forma que las ranuras donde se meten las tarjetas de memoria MMC pueden actuar como bus, de forma que se le puede conectar wireless y otros implementos.

* Autorización USB: Pues resulta que como parte de los esfuerzos para soportar USB wireless, ahora la pila USB puede configurarse a través de sysfs, para que los dispositivos USB conectados al sistema no pasen a funcionar inmediatamente.

* Antifragmentación de la memoria: reducen la fragmentación de la memoria, es decir, que permitan satisfacer grandes asignaciones de memoria contigua (es decir, múltiplos de 4KB en x86 - 8KB, 12KB, 16 KB).

* Drivers para dispositivos inalámbricos: En Linux se añaden drivers continuamente, pero en esta ocasión se ha añadido una buena cantidad.

PulseAudio que sustituye a esound como servidor de sonidos. La mejora aporta soporte plug-n-play de forma que las conexiones de audio funcionen al momento de ser conectadas. También podemos dirigir de forma óptimas las salidas de audio, de forma que podemos escuhar música por unos altavoces usb y mantenemos al mismo tiempo una conversación por los auriculares. Otra aplicación consiste en la posibilidad de disminuir automáticamente el audio del reproductor de video cuando recibimos una llamada de skype.

Y ahora, en la alpha 4, se incluyen estas otras mejoras:

Transsmision es el nuevo cliente de descargas torrent por defecto, y por lo tanto se elimina Gnome BitTorrent. Transmission es un cliente liviano, gratuito y de código abierto para la red BitTorrent. Está disponible bajo la licencia MIT, con algunas partes GPL, y es multiplataforma( linux, mac, BSD, BeOS).

Vinagre nuevo cliente VNC de conexión remota a escritorios, conectados a una red (pasos para el control remoto del ordenador por internet). Con Vinagre podremos controlar diversos escritorios simultaneamente, puede buscar servidores VNC en la red vía Ahavi, y puede mantener registros de conexiones favoritas y de usos recientes. Pueden obtener más información en http://www.gnome.org/projects/vinagre/

Brasero es la nueva aplicación por defecto para la grabación de CD’s y DVD’s, incluido en el navegador de archivos de gnome Nautilus. Sustituye a Serpiente que se usaba sólo para la grabación de CD’s de audio. Se simplifica la grabación de discos al poder realizar la grabación mientras navegamos con Nautilus.

World Clock Applet sustituye al applet anterior, y añade nuevas características como poder ver la hora de otros paises y conocer el tiempo (genial!!).

GVFS sustituye al desfasado gnome GVFS. Aporta nuevas funciones al navegador de ficheros Nautilus mediante el control de ficheros y sus privilegios bajo el control de PolicyKit.

GNOME System Monitor nueva imágen para el monitor de recursos de gnome, con gráficos mejorados y un scroll suave.

Virtualization KMV estará mantenido por el kernel de ubuntu. libvirt y virt-manager han sido adaptados para ubuntu. El kernel incluye modificaciones que mejoraran el acceso de entrada/salida.

Firewall ufw (Uncomplicated Firewall) es una nueva aplicación fácil de usar para la administración del cortafuegos que desde siempre lleva ubuntu.

Wubi como una nueva opción de instalación para los usuarios de windows, de forma que les permite instalar y desinstalar ubuntu.

Video promocional de Edulibre

Les presento el nuevo video promocional para edulibre, lo hicieron los de diseño que trabajaron para edulibre. Quedó muy bonito y la idea del video es crear un poco de conciencia para ayudarnos.
Se los dejo....

Hamachi en ubuntu 7.10

Por un proyecto de la universidad necesito hacer una red por internet con Hamachi. Sirve para jugar, compartir archivos, música, etc. a través de las redes VPN (ya sabes, redes virtuales que funcionan a través de Internet [COMO UNA LAN PERO EN INTERNET]).

Mi sistema operativo es Ubuntu 7.10 , les voy a dejar una guía de como instalarlo desde consola:

Empezamos con los comandos:

$ sudo modprobe tun
$ sudo gedit /etc/modules

agregar: tun.
cerrar y guardar.

ahora corra el siguiente codigo:

$ ls /dev/net/tun

Debe de tener "/dev/net/tun"
Si no puede correr el siguiente código para crear la carpeta:

$ sudo mkdir /dev/net
$ sudo mknod /dev/net/tun c 10 200

Si les da problemas borren la carpeta "tun" (con el comando rmdir tun) y vuelvan a crearla usando el comando de arriba: mkdir /dev/net

Bajen la última versión de hamachi http://files.hamachi.cc/linux/ o de:

https://secure.logmein.com/products/hamachi/list.asp o

con código:

$ wget wget http://files.hamachi.cc/linux/hamachi-0.9.9.9-20-lnx.tar.gz

Extraingan hamachi

$ tar -zxvf hamachi-0.9.9.9-20-lnx.tar.gz

Ubíquense en el directorio de hamachi:

$ cd hamachi-0.9.9.9-20-lnx/

Instalar hamachi

$ sudo make install

cambiamos a la carpeta usr/bin

$ sudo cd /usr/bin

y extraemos el binario de hamachi:

$ sudo upx -d hamachi

Inicien tuncfg:

$ sudo /sbin/tuncfg

Creen un grupo de hamachi:

$ sudo groupadd hamachi

Agregarse al grupo de hamachi creado:

$ sudo gpasswd -a NOMBREUSUARIO hamachi

Agregar al root al grupo de hamachi

$ sudo gpasswd -a root hamachi

Cambiar los permisos para el socket

$ sudo chmod 760 /var/run/tuncfg.sock

Cambiar el grupo del archivo

$ sudo chgrp hamachi /var/run/tuncfg.sock

Crear la clave RSA:

$ hamachi-init

Ahora ya podemos iniciar hamachi

$ sudo hamachi start

Crear el nombre de una cuenta de hamachi

$ sudo hamachi set-nick NICKQUEQUIERAS

Loguearse a la red de hamachi

$ sudo hamachi login

Entrar a alguna red

$ sudo hamachi join "red" password

por ejemplo:

$ sudo hamachi join "UT2004 Lobago" lobago

También se puede crear una red propia:

$ sudo hamachi create NUESTRARED

con esto ya estamos dentro de la red, pero aparecemos como offline, para cambiarnos a online lo hacemos con:

$ sudo hamachi go-online "NOMBRERED"

y para ver el estado de todos los usuarios que se encuentran conectados a nuestras redes lo hacemos con:

$ sudo hamachi list

se mira asi:

* [homelan]
     * 5.0.0.15
     x 5.0.0.16        ronny
       5.0.0.17        bubba
     * 5.0.0.18        zhopa      10.0.0.100:45634

El * es que están online, cuando nosotros estamos como offline no tendremos el * en el nombre de la red.

Para ver el estado de nuestro hamachi lo hacemos con:

$ sudo hamachi

Y para ver los comandos que tiene hamachi lo hacemos con:

$ sudo hamachi h


Articulo tomado de:

http://www.ubuntu-es.org/index.php?q=node/67368
http://www.lobago.com.ar/foro/showthread.php?t=1415
http://files.hamachi.cc/linux/README
http://www.opensourcespot.org/content/view/786/157/
http://www.youtube.com/watch?v=FZRC_mkVx7o

Nuevos efectos de compiz fusion

Les dejo un video con los nuevos efectos que tiene compiz fusion, (efectos visuales en linux). Están bastante bonitos.