#include <unistd.h> ssize_t readlink(const char *restrict pathname, char *restrict buf, size_t bufsiz); #include <fcntl.h> /* Définition des constantes AT_* */ #include <unistd.h> ssize_t readlinkat(int dirfd, const char *restrict pathname, char *restrict buf, size_t bufsiz);Exigences de macros de test de fonctionnalités pour la glibc (consulter feature_test_macros(7)) :
readlink():
_XOPEN_SOURCE >= 500 || _POSIX_C_SOURCE >= 200112L || /* glibc <= 2.19 : */ _BSD_SOURCE
readlinkat():
Depuis la version 2.10 de la glibc : _POSIX_C_SOURCE >= 200809L Avant la version 2.10 de la glibc : _ATFILE_SOURCE
Si pathname est un chemin relatif, il est interprété par rapport au répertoire référencé par le descripteur de fichier dirfd (plutôt que par rapport au répertoire courant du processus appelant, comme cela est fait par readlink() pour un chemin relatif).
Si pathname est relatif et si dirfd a la valeur spéciale AT_FDCWD, alors pathname est interprété relativement au répertoire de travail du processus appelant, comme pour readlink().
Si pathname est absolu, alors dirfd est ignoré.
Depuis Linux 2.6.39, pathname peut être une chaîne vide, auquel cas l'appel opère sur le lien symbolique référencé par dirfd (qui peut avoir été obtenu par open(2) avec les drapeaux O_PATH et O_NOFOLLOW).
Consultez openat(2) pour une explication de la nécessité de readlinkat().
L'utilisation d'un tampon de taille statique risque de ne pas fournir assez de place pour le contenu du lien symbolique. La taille nécessaire au tampon peut être lue dans la valeur stat.st_size renvoyée par un appel à lstat(2) sur le lien. Cependant, le nombre d'octets écrits par readlink() et par readlinkat() devrait être vérifié pour s'assurer que la taille du lien symbolique n'a pas augmenté entre les appels. L'allocation dynamique du tampon pour readlink() et pour readlinkat() résout aussi un problème habituel de portabilité si PATH_MAX est utilisé comme taille de tampon, car la définition de cette constante n'est pas garantie selon les POSIX si le système n'a pas ce genre de limite.
#include <limits.h> #include <stdio.h> #include <stdlib.h> #include <sys/stat.h> #include <unistd.h>
int
main(int argc, char *argv[])
{
char *buf;
ssize_t nbytes, bufsiz;
struct stat sb;
if (argc != 2) {
fprintf(stderr, "Usage: %s <pathname>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (lstat(argv[1], &sb) == -1) {
perror("lstat");
exit(EXIT_FAILURE);
}
/* Ajouter un à la taille du lien, pour pouvoir déterminer si le tampon
renvoyé par readlink() a été tronqué. */
bufsiz = sb.st_size + 1;
/* Certains liens symboliques magiques dans (par exemple) /proc et /sys
indiquent 'st_size' comme zéro. Dans ce cas, prendre PATH_MAX
comme estimation « acceptable ». */
if (sb.st_size == 0)
bufsiz = PATH_MAX;
buf = malloc(bufsiz);
if (buf == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
nbytes = readlink(argv[1], buf, bufsiz);
if (nbytes == -1) {
perror("readlink");
exit(EXIT_FAILURE);
}
/* N'afficher que 'nbytes' de 'buf', car il ne contient
pas d'octet NULL final ('\0'). */
printf("'%s' pointe vers '%.*s'\n", argv[1], (int) nbytes, buf);
/* Si la valeur renvoyée était égale à la taille du tampon, la cible du
lien était plus grande que prévu (peut-être parce que la cible
a changé entre l'appel à lstat() et l'appel à readlink()).
Avertir l'utilisateur que la cible renvoyée peut avoir
été tronquée. */
if (nbytes == bufsiz)
printf("(Il se peut que le tampon renvoyé ait été tronqué)\n");
free(buf);
exit(EXIT_SUCCESS);
}
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à