Espacio de tecnologia, software libre y sus derivados. Una horda de monos entrenados escriben de vez en cuando por aqui algunas noticias, opiniones e incluso alguna que otra cosa fuera del tema. Maqueros, favor de abstenerse que no somos lo suficientemente guapos.
November 11, 2009 a las 1:00 pm por Edwin Plauchu · Archivado en FreeBSD
# cd /usr/ports/databases/mysql51-server
# make && make install
Agregar al fichero /etc/rc.conf lo siguiente para que mysql server arranque junto con el sistema operativo
# echo ‘mysql_enable=”YES”’ >> /etc/rc.conf
Ahora reinicie el equipo
# reboot
MySQL ya se encuentra instalado.. ahora creamos una base de datos llamada uno… asignada al usuario user con el password “password”…. Esta sera accesible desde cualquier direccion ip… gracias al comodin %
mysql> create database uno;
mysql> grant all on uno.* to user@’%’ identified by “password”;
August 13, 2009 a las 4:25 pm por Edwin Plauchu · Archivado en Programacion, FreeBSD
Se pueden tener apuntadores a cualquier tipo de variable.
Para entender perfectamente este desmadre de los apuntadores… aprendete estas reglas magicas:
1.- Un apuntador es una variable que contiene la dirección en memoria de otra variable.
main()
{
int x = 1;
int *ap; //Apuntador que permite
//ser usado con variables enteras
ap = &x; //Se le asigna la direccion
//de memoria que alverga el valor 1
printf("Direccion de el apuntador ap:%x",ap);
}
La consola termina imprimiendonos esto: Imprime la direccion de el apuntador ap:bf9ed410
2.- Un apuntador puede ser desreferenciado, para accesar a el valor que contiene (a esto se le llama acceso indirecto) esto se logra agregando el * al identificador del apuntador:
main()
{
int x = 1;
int *ap; //Apuntador que permite
//ser usado con variables enteras
ap = &x; //La direccion de memoria de x
//se asigna a la direccion de
// memoria que alberga el apunt
// ador ap
printf("Valor de el apuntador ap:%d",*ap);
}
La consola termina imprimiendonos esto: Valor de el apuntador ap :1
3.- C no es muy estricto en la asignación de valores de diferente tipo (entero a apuntador - apuntador a entero). Así que es perfectamente legal (aunque el compilador genera un aviso de cuidado).
main()
{
int x;
int y;
int *ap;
y = 3;
ap = y; //Ahora se apunta
// a la localidad de
// memoria 3
x = ap; //Aqui x recibe el valor
//3
printf("Localidad de memoria:%d",x);
}
La consola termina imprimiendonos esto: Localidad de memoria x :3
4.- No se puede usar un apuntador, si no esta este previamente inicializado
Por lo que:
main()
{
int *ap;
*ap = 100;
}
puede generar un error en tiempo de ejecución o presentar un comportamiento errático.
El uso correcto será:
main()
{
int *ap;
int x;
ap = &x;
*ap = 100;
}
5.- En los apuntadores a estructuras: Se usa la notación p->member
main()
{
typedef struct {
char member_1;
int member_2;
} s_type;
s_type x={'U',2}, *p = &x;
p->member_1 = 'R'; // Equivale a (*p).member_1 = 'R';
//Observece como sacamos el contenido de uno de
// los elementos de la estructura de forma indirecta
printf("Caracter encontrado:%c",(*p).member_1);
}
Imprime en consola Caracter encontrado:R
Con estas reglas basica ahora podras comprender la fabulosa Aritmetica de punteros
Me pidieron un programita hecho en C residente en memoria. Un demonio pues!…
Aqui les dejo el codigo base del daemon unix tradicional.
El daemon lo hice para un IBM AIX 5.3 sobre arquitectura power pc.
Y poco despues lo compile en linux, y no hubo nada de problema.. codigo 2000% porciento guapo y portable.
/**********************************
* UNIX Daemon Server Programming *
* Written by Edwin Plauchu *
* mailto:pianodaemon@gmail.com *
**********************************/
#include stdio.h
#include stdlib.h
#include fcntl.h
#include signal.h
#include unistd.h
#include string.h
#define RUNNING_DIR "/tmp"
#define LOCK_FILE "cacherd.lock"
#define LOG_FILE "cacherd.log"
void log_message(filename,message)
char *filename;
char *message;
{
FILE *logfile;
logfile=fopen(filename,"a");
if(!logfile) return;
fprintf(logfile,"%sn",message);
fclose(logfile);
}
void signal_handler(sig)
int sig;
{
switch(sig) {
case SIGHUP:
log_message(LOG_FILE,"Senal de hangup cachada");
break;
case SIGTERM:
log_message(LOG_FILE,"Senal de Terminacion cachada");
exit(0);
break;
}
}
void daemonize(){
int i,lfp;
char str[10];
// Primero obtenemos el indentificador de Proceso
if( getppid() == 1 ) return;
// Ahora generamos un proceso hijo y obtenemos su PID
// mediante la variable i
i=fork();
// Comprobamos que el proceso hijo este lanzado de manera correcta
// Verificando los posibles ERRORES de lanzamiento
// En caso de existir un error de lanzamiento en el proceso hijo
// procedemos a la finalizacion del proceso padre
if (i<0) { exit(1); } // fork error, el proceso hijo no pudo ser creado
if (i>0) { exit(0); } /* Padre existe */
// Proceso hijo (Demonio) continua
setsid(); // Crea una sesión y define el ID de grupo del proceso
/* Cerrar todos los descriptores de archivo
OJO: Esto evita que el hijo use los mismos decriptores de fichero que el padre*/
for (i=getdtablesize();i>=0;–i) close(i);
i=open(”/dev/null”,O_RDWR); dup(i); dup(i); /* handle standart I/O */
umask(027); /* Establece los permisos que le seran dados a los nuevos archivos a crear */
chdir(RUNNING_DIR); /* Cambia el directorio de ejecucion */
/* Abre el archivo de bloqueo en modo lectura/escritura, pero
si el archivo no existiece, lo crea con el permiso 640 */
lfp=open(LOCK_FILE,O_RDWR|O_CREAT,0640);
if (lfp<0) { exit(1); } /* No puede ser abierto */
if (lockf(lfp,F_TLOCK,0)<0) exit(0); /* No puede ser bloqueado el fichero para este proceso*/
/* Primera instancia continua */
sprintf(str,"%dn",getpid());
// Escribimos el PID al fichero de bloqueo
write(lfp,str,strlen(str));
signal(SIGCHLD,SIG_IGN); /* Ignora hijo */
signal(SIGTSTP,SIG_IGN); /* Ignora Senales tty */
signal(SIGTTOU,SIG_IGN);
signal(SIGTTIN,SIG_IGN);
signal(SIGHUP,signal_handler); /* Cacha Senal hangup (kill -1 PID)*/
signal(SIGTERM,signal_handler); /* Cacha Senal de Terminacion (kill -15 PID)*/
}
int main(){ daemonize(); while(1) sleep(1); }
July 8, 2009 a las 9:27 am por Edwin Plauchu · Archivado en Microsoft, FreeBSD, Linux
Navegando hace unos instantes, encontré este “humor gráfico” en el cual podemos apreciar los distintos puntos de vista de los diferentes sistemas operativos, unos contra otros, como por ejemplo; como ve un “maquero” a un “linuxero” y viceversa. Espero que les guste.
May 30, 2009 a las 2:30 pm por Edwin Plauchu · Archivado en FreeBSD
Siempre es mejor compilar nuestro propio kernel BSD porque obtendremos uno más esbelto y rápido que el genérico que viene en la instalación. Bien, de manera rápida y sucia esta es la receta:
# cd /usr/
# wget -c http://ftp.netbsd.org/pub/NetBSD/NetBSD-current/tar_files/src/sys.tar.gz
Nos movemos al directorio según la arquitectura, en este caso i386:
# cd /usr/src/sys/arch/i386/conf/
# cp GENERIC MYPLAUCHUKERNEL
Ahora debemos editar las opciones del kernel.
# nano ./MYPLAUCHUKERNEL
Ejecutamos config para generar las directivas de compilacion para nuestro nuevo kernelito bsdero.
# config MYPLAUCHUKERNEL
# cd ../compile/MYPLAUCHUKERNEL
# make depend && make
Renombramos el viejo kernel que está en raíz: # mv /netbsd /netbsd.anterio.bak
