Buenas noches, amigos
Realizando las prácticas del capítulo 11 de Programación en  Linux con ejemplos de Kurt Wall, el referido a n-curses, me encuentro con el siguiente problema.

Parece ser que para habilitar la depuración es necesario linkar a ncurses_g y habilitar trace(N) en el código. Para probarlo propone el siguiente código:

/* Filename: depurador.c */
 
#include <curses.h>
 
int main (void)
{
	initscr();
 
	trace(TRACE_CALLS);
	printw("Establecer nivel de depuración para TRACE_CALLS");
	refresh();
	endwin();
	return 0;
}
 

 
El caso es que no tenía la biblioteca libncurses_g.a y la instalé den debian 7 con
 sudo apt-get install libncurses5-dbg

Al ejecutar el comanda de compilación y depuración
gcc depurador.c -o depurador -lncurses_g

La cantidad de errores es enorme, pongo la parte final
/usr/lib/gcc/i486-linux-gnu/4.7/../../../../lib/libncurses_g.a(lib_echo.o): In function `echo':
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:52: undefined reference to `_nc_tracing'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:53: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:56: undefined reference to `_nc_retrace_int'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:52: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:52: undefined reference to `_tracef'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:53: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:54: undefined reference to `_nc_retrace_int'
/usr/lib/gcc/i486-linux-gnu/4.7/../../../../lib/libncurses_g.a(lib_echo.o): In function `noecho':
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:70: undefined reference to `_nc_tracing'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:71: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:74: undefined reference to `_nc_retrace_int'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:70: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:70: undefined reference to `_tracef'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:71: undefined reference to `SP'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_echo.c:72: undefined reference to `_nc_retrace_int'
/usr/lib/gcc/i486-linux-gnu/4.7/../../../../lib/libncurses_g.a(lib_erase.o): In function `werase':
/tmp/buildd/ncurses-5.9/ncurses/base/lib_erase.c:54: undefined reference to `_nc_tracing'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_erase.c:54: undefined reference to `_tracef'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_erase.c:91: undefined reference to `_nc_retrace_int'
/tmp/buildd/ncurses-5.9/ncurses/base/lib_erase.c:91: undefined reference to `_nc_retrace_int'
collect2: error: ld returned 1 exit status


Agradecería me dijérais que es lo que puede pasar. ¿Es posible que haya instalado una libreria de depuración que no corresponda con la versión que tenga instalada de ncurses?

Muchas gracias.

Estimados amigos,

Estoy siguiendo el Manual de Programación en Linux de Kurt Wall y en su capítulo 10 muestra como trabajar con la base de datos de Berkeley. El caso es que el código que pongo a continuación no compila bien. Los fallos de compilación del código adjunto están en db_open y DB->close aunque linke a  
gcc abrir_db2.c -o abrir_db2 -lbd

abrir_db2.c: In function ‘main’:
abrir_db2.c:37:5: error: expected identifier or ‘(’ before ‘->’ token


Tampoco se cómo buscar por paginas mán de la Berkeley (si las tiene) sobre todo por averiguarr que versión tengo instalada y así intentar buscar algo de documentación para interaccionar desde C con ella. Al menos lo más básico, abrir, cerrar, añadir registros, etc.

 
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <db.h>
 
int main (void)
{
		DB puntero_db; /* descriptor de base de datos */
		int valor_retornado;
 
		valor_retornado = db_open("test.db", DB_BTREE, DB_CREATE, 0600, NULL, NULL, &puntero_db);
 
		if (valor_retornado) {
			perror ("db_open");
			exit(EXIT_FAILURE);
		}
 
		DB->close(puntero_db,0);
		exit(EXIT_SUCCESS);
 
		return EXIT_SUCCESS;
}
 

Respecto a la Berkeley DB encontré esta página:http://docs.oracle.com/cd/E17076_02/html/api_reference/C/frame_main.html pero tampoco funciona el código tomando estas funciones. Y esta otra https://bbs.archlinux.org/viewtopic.php?id=78032 pero tampoco consigo nada, ya digo creo que necesitaría saber que Berkeley tengo instalada.

Me da la sensación que el libro en general es demasiado antiguo porque en capítulos anteriores, por ejemplo en el que habla de archivos, toca el sistema ext-2 y Debian 7, ya monta ext-4. El caso es que me da que en los próximos capítulos a los que estoy deseando llegar donde toca la manipulación de pantalla con ncurses, redes y demás me pueda encontrar con los mismos problemas. Quisiera que me dieras vuestra opinión al respecto y, si existe algún manual más moderno me lo comentéis.

Un saludo.

Buenas noches de nuevo, compañeros del foro

De nuevo me dirijo a vosotros con un problema de programación en linux. Esta vez en relación al bloqueo de descriptores de archivo.

Como he comentado en otra ocasión, estoy siguiendo el libro de Prentice Hall de Kurt Walt Programación en Linux y, aunque lentamente voy progresando, gracias al libro y a vuestra ayuda.

En esta ocasión se trata de ejecutar el programa desde dos ventanas distintas  (./lockit /tmp/foo) y ver como permite a ambos el bloqueo de lectura (del primer byte) pero cuando en una de ellas pasas al bloqueo de escritura (El programa usa getchar() para detener la ejecución) debe decirte que el pid del programa que lo ejecuta en el otro terminal aún lo tiene bloqueado para lectura y no permitírlo. Bien, esto no me ha funcionado, incluso ejecutándolo en un único terminal la salida que obtengo al ejecutar el bloqueo de escritura es:

          bloqueo de escritura ya establecido por -1075043608

cuando debería escribir lo que haya en el campo lock.l_pid, que según la página man de fcntl es lo que debe imprimir.

En fin, si podéis ayudarme os lo agradeceria. Más abajo el código.

Un saludo.

/*
 * lockit.c - Establece el bloqueo en un archivo
 */
#include <unistd.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
 
/* Establece un bloqueo de tipo en el descriptor fd */
void setlock(int fd, int type);
 
int main ( int argc, char *argv[] )
{
		int fd;
		/* Abre el archivo */
		fd = open(argv[1], O_RDWR | O_CREAT, 0666);
		if (fd < 0) {
			perror("open");
			exit(EXIT_FAILURE);
		}
 
		/* Establece un bloqueo de lectura */
		setlock(fd, F_RDLCK);
		printf("PID %d bloqueado para lectura %s\n", getpid(), argv[1]);
		getchar();
 
		/* Desbloqueo */
		setlock(fd, F_UNLCK);
		printf("PID %d unlocked %s\n", getpid(), argv[1]);
		getchar();
		close(fd);
 
		/* Establece un bloqueo de escritura */
		setlock(fd, F_WRLCK);
		printf("PID %d bloqueado para escritura %s\n", getpid(), argv[1]);
 
 
		return EXIT_SUCCESS;
}				/* ----------  end of function main  ---------- */
 
void setlock(int fd, int type)
{
		struct flock lock;
		char msg[80];
 
		/* Describe el bloqueo que queremos */
		lock.l_whence = SEEK_SET;
		lock.l_start = 0;
		lock.l_len = 1; /* bloquea un solo bit */
 
		while (1) {
			lock.l_type = type;
			/* Bloqueo establecido y vuelta al que llama */
			if ((fcntl(fd, F_SETLK, &lock)) == 0)
				return;
 
			/* Busca por qué no podemos establecer el bloqueo */
			fcntl(fd, F_GETLK, &lock);
			if(lock.l_type != F_UNLCK) {
				switch(lock.l_type) {
					case(F_RDLCK):
						sprintf(msg, "bloqueo de lectura ya establecido por %d\n", lock.l_pid);
						break;
					case(F_WRLCK):
						sprintf(msg, "bloqueo de escritura ya establecido por %d\n", lock.l_pid);
						break;
				}
			}
			puts(msg);
			getchar();
		}
}
 

Buenas noches,

Tengo dudas con el siguiente código que muestra como usar fstat con descriptores de archivos en linux. El ejemplo está sacado del libro PROGRAMACIÓN EN LINUX (de Prentice Hall).  La salida es la siguiente cuando ejecuto

$./mstat mstat.c

ARCHIVO: mstat.c
        INODE: 1
     UNIDAD: 1738,751700
         NODO: 0
       ENLACES: 1
            UID: -1215903496
        GID: -1216286732
         TIPO: Tipo desconocido
     TAMAÑO: -1217516891
TAMAÑO DE BLOQUE: -1216286732
    BLOQUES: 134520036
      ACCESO: Tue Nov 12 06:31:52 1935
MODIFICACION: Sun Jun 21 08:42:40 1931
      CAMBIO: Tue Nov 12 06:32:40 1935

No entiendo porqué salen esos datos que creo incorrectos como el UID, el GID, el tamaño, el tamaño del bloque etc. Si fueran tan amables de orientarme. Muchas gracias.

El código fuente es el siguiente:


#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main ( int argc, char *argv[] )
{
      struct stat buf;
      mode_t mode;
      char type[80];
      int fd;

      /* valida la linea de comandos */

      if(argc != 2) {
         puts("USAGE: mstat {file}");
         exit(EXIT_FAILURE);
      }

      /* abre el archivo  */

      if((fd = open(argv[1], O_RDONLY)) < 0) {
         perror("open");
         exit(EXIT_FAILURE);
      }

      /* obtiene las estadísticas del archivo */

      mode = buf.st_mode;
      printf("      ARCHIVO: %s\n", argv[1]);
      printf("        INODE: %ld\n", buf.st_ino);
      printf("     UNIDAD: %d,%d\n", major(buf.st_dev), minor(buf.st_dev));
      printf("         NODO: %#o\n", mode & ~(S_IFMT));
      printf("       ENLACES: %d\n", buf.st_nlink);
      printf("            UID: %d\n", buf.st_uid);
      printf("        GID: %d\n", buf.st_gid);
      
      if(S_ISLNK(mode))
         strcpy(type, "Enlace simbólico");
      else if(S_ISREG(mode))
         strcpy(type, "archivo normal");
      else if(S_ISDIR(mode))
         strcpy(type, "Directorio");
      else if(S_ISCHR(mode))
         strcpy(type, "Unidad de caracteres");
      else if(S_ISBLK(mode))
         strcpy(type, "Unidad de bloque");
      else if(S_ISFIFO(mode))
         strcpy(type, "FIFO");
      else if(S_ISSOCK(mode))
         strcpy(type, "Socket");
      else
         strcpy(type, "Tipo desconocido");
      printf("         TIPO: %s\n", type);
      printf("     TAMAÑO: %ld\n", buf.st_size);
      printf("TAMAÑO DE BLOQUE: %ld\n", buf.st_blksize);
      printf("    BLOQUES: %d\n", (int)buf.st_blocks);
      printf("      ACCESO: %s", ctime(&buf.st_atime));
      printf("MODIFICACION: %s", ctime(&buf.st_mtime));
      printf("      CAMBIO: %s", ctime(&buf.st_ctime));

      /* cierra el archivo */
      if(close(fd) <0) {
         perror("close");
         exit(EXIT_FAILURE);
      }
      return EXIT_SUCCESS;