Diferencias

Muestra las diferencias entre dos versiones de la página.

--- unix-es [2013/04/25 16:15] – [Lectura/escritura de archivos] lmateu
+++ unix-es [2016/11/15 13:15] (actual) – [Características de un archivo] lmateu
@@ Línea 31: / Línea 31: @@
   char *buf;
   int fd;
-  ssize_t nbytes, leidos, escritos;
+  size_t nbytes;
+  ssize_t leidos, escritos;
   leidos = read(fd, buf, nbytes);
@@ Línea 82: / Línea 83: @@
     char c;
-    return (read(0, &c, 1)==1? (unsigned char)c : EOF);
+    return (read(0, &c, 1)==1? c : EOF);
   }
@@ Línea 88: / Línea 89: @@
     int c;
-    while((c=getchar())!=EOF)
+    while( (c= migetchar()) != EOF)
       putchar(c);
@@ Línea 105: / Línea 106: @@
     static ssize_t n=0;
-    if(n==0) { /* buffer vaco */
+    if(n==0) { /* buffer vacio */
       n=read(0,buf, sizeof buf);
       p=buf;
     }
-    return (--n>=0? (unsigned char)*p++ : EOF);
+    return (--n>=0? *p++ : EOF);
   }
@@ Línea 116: / Línea 117: @@
     int c;
-    while((c=migetchar())!=EOF)
+    while( (c= migetchar()) != EOF)
       putchar(c);
     return 0;
@@ Línea 172: / Línea 173: @@
   /* Uso: micp from to */
   #include <stdio.h>
-  #include <stdlib.h>
+  #include <sys/types.h>
-  #include <stdarg.h>
+  #include <sys/stat.h>
   #include <fcntl.h>
+  #include <stdlib.h>
   #include <unistd.h>
+  #include <errno.h>
-  void error(char *fmt, ...) {
+  #define SIZE 8192
-    va_list args;
-    va_start(args, fmt);
-    fprintf(stderr, "Error: ");
-    vfprintf(stderr, fmt, args);
-    fprintf(stderr, "\n");
-    va_end(args);
-    exit(1);
-  }
   int main(int argc, char *argv[]) {
-    int f1, f2;
+    int in, out;
     ssize_t n;
-    char buf[BUFSIZ];
+    char buf[SIZE];
-    if (argc!=3)
+    if (argc!=3) {
-      error("Use: my_cp from to");
+      fprintf(stderr, "Use: %s <from> <to>\n", argv[0]);
+      exit(1);
-    if ((f1= open(argv[1], O_RDONLY))==-1)
+    }
-      error("Can't open %s", argv[1]);
+    if ((in= open(argv[1], O_RDONLY))==-1) {
-    if ((f2= creat(argv[2], 0666))==-1)
+      perror(argv[1]);
-      error("Can't open %s", argv[2]);
+      exit(2);
+    }
+    if ((out= creat(argv[2], 0666))==-1) {
+      perror(argv[2]);
+      exit(3);
+    }
     /* usando stats se pueden mantener los permisos */
-    while ((n= read(f1, buf, BUFSIZ))>0)
+    while ((n= read(in, buf, SIZE))>0) {
-      if(write(f2, buf, n)!=n)
+      if (write(out, buf, n)!=n) {
-        error("Write error on file %s", argv[2]);
+        perror(argv[2]);
+        exit(4);
+      }
+    }
+    if (n<0) {
+      perror(argv[1]);
+      exit(5);
+    }
+    close(in);
+    close(out);
     return 0;
   }
+==== Cambiar los permisos de un archivo ====
+  #include <sys/stat.h>
+  char *path;
+  mod_t mode;
+  chmod(path, mode);
 ==== Borrar un archivo ====
@@ Línea 220: / Línea 238: @@
   unlink(path);
+==== Cambiar el nombre de un archivo ====
+Se usa la funcion //rename//:
+  #include <stdio.h>
+  char *oldpath, *newpath;
+  rename(newpath, oldpath);
+==== Crear un link duro ====
+Se usa la función //link//:
+  #include <unistd.h>
+  char *path, *newpath;
+  link(path, newpath);
+Se usa para crear un nombre sinónimo de un archivo existente.
+También se puede crear un link desde el shell de comandos:
+  % ln datos.txt datos2.txt
+En este caso datos.txt y datos2.txt se refieren al mismo archivo.
+Si se edita datos.txt y se introduce un cambio, datos2.txt va a reflejar ese cambio.
+Si se borra datos.txt, el archivo datos2.txt sigue siendo válido.
+También se puede crear un link duro en un directorio distinto del directorio en donde aparece el nombre
+original del archivo.  La única restricción es que //ambos nombres se deben encontrar en directorios
+de la misma partición de disco//.
+==== Crear un link simbólico ====
+Se usa la función //symlink// para crear un nombre sinónimo de un archivo existente:
+  #include <unistd.h>
+  char *path, *newpath;
+  symlink(path, newpath);
+También se puede crear un link simbólico desde el shell de comandos:
+  % ln -s datos.txt datos2.txt
+En este caso datos2.txt es un nombre alternativo para datos.txt.
+¡Pero cuidado!  La desventaja de los links simbólicos (con respecto a los links duros)
+es que si se borra datos.txt, datos2.txt ya no es válido.
+La ventaja con respecto a los links duros es que sí se pueden crear links simbólicos
+con el nuevo nombre en una partición distinta de la partición en donde se ubica el
+nombre original.
 ==== Acceso directo ====
@@ Línea 264: / Línea 330: @@
   buf= getcwd(buf, size); /* guarda en buf pathname absoluto del
-                            directorio actual, retorna NULL si error */
+                            directorio actual, retorna NULL en caso de error */
+  chdir(name);    /* cambia el directorio actual.  Retorna !=0 en caso de error. */
 Llamadas al sistema (sección 2):
@@ Línea 293: / Línea 360: @@
   st_size             tamaño del archivo en bytes
   st_atime            dia y hora del último acceso
-  st_ctime            día y hora del último cambio (p.ej. perms)
+  st_ctime            día y hora de creación
   st_mtime            día y hora de la última modificación
@@ Línea 303: / Línea 370: @@
   S_ISREG             regular file?
   S_ISFIFO            named pipe?
+  S_ISLNK             link simbólico?
-Los atributos se pueden modificar con las llamadas a sistema:
+Esta función es usada por el comando ls -l para averiguar las características de un archivo:
+   $ ls -l index.html
+   -rw-r--r-- 1 lmateu inv 3851 Aug 16  2007 index.html
+La mayoría de estos atributos se pueden cambiar con llamadas al sistema, como por ejemplo:
   chmod(path, perms);
   chown(path, owner, group);
+  utime(path, ...);
-También es posible falsificar el "time stamp" de un archivo, con la función utime (ver manual). Esto
+La función utime (ver manual) permite "falsificar" el "time stamp" de un archivo. Esto
 lo usa el comando tar para restaurar la fecha y hora de creación y modificación de los archivos.
-=== Ejemplo: Listar directorios recursivamente ===
+=== Ejemplo 1: Determinar si 2 nombres de archivos corresponden al mismo archivo ===
+Dada la existencia de los links duros, el nombre de un archivo no basta para identificarlo, porque
+nombres distintos pueden referirse al mismo archivo.  La verdadera identidad de un archivo
+consiste en la identificación de la partición de disco en donde se ubica (campo st_dev) y el inodo
+asignado (campo st_ino). Usando estos 2 campos se puede programar un comando que determina
+si dos nombres están asociados al mismo archivo.  Llamaremos a este comando linked:
+Ejemplo de uso:
+<code>
+  % cp a.txt b.txt
+  % ln a.txt c.txt
+  % linked a.txt b.txt
+  not linked
+  % linked a.txt c.txt
+  linked
+  %
+</code>
+Esta es la implementación usando stat:
+<code>
+  /* linked.c */
+  #include <stdio.h>
+  #include <sys/stat.h>
+  #include <stdlib.h>
+  #include <unistd.h>
+  int main(int argc, char **argv) {
+    struct stat st1, st2;
+    if (stat(argv[1], &st1)!=0) {
+      fprintf(stderr, "can't stat %s\n", argv[1]);
+      exit(1);
+    }
+    if (stat(argv[2], &st2)!=0) {
+      fprintf(stderr, "can't stat %s\n", argv[2]);
+      exit(1);
+    }
+    if (st1.st_dev==st2.st_dev && st1.st_ino==st2.st_ino)
+      printf("linked\n");
+    else
+      printf("not linked\n");
+    return 0;
+  }
+</code>
+Si 2 nombres de archivos están en directorios de particiones distintas, entonces
+no pueden ser el mismo archivo.  La identificación de una partición se almacena
+en st_dev.  Si están en la misma partición y corresponden al mismo archivo entonces
+tendrán el mismo valor en st_ino.
+=== Ejemplo 2: Listar directorios recursivamente ===
   #include <stdio.h>