Comment mettre en œuvre readlink pour trouver le chemin

À l'aide de la readlink fonction utilisée comme une solution à Comment puis-je trouver l'emplacement de l'exécutable en C?, comment pourrais-je obtenir le chemin d'accès dans un tableau de char? Aussi, ce qui ne les variables de buf et de bufsize représentent et comment les initialiser?

EDIT: je suis en train d'essayer d'obtenir le chemin d'accès du programme en cours d'exécution, tout comme la question ci-dessus. La réponse à cette question, a déclaré à l'utilisation readlink("proc/self/exe"). Je ne sais pas comment faire pour la mettre dans mon programme. J'ai essayé:

char buf[1024];  
string var = readlink("/proc/self/exe", buf, bufsize);

C'est évidemment incorrect.

InformationsquelleAutor a sandwhich | 2011-04-02

c++executable linux path

Ce Utiliser le readlink() fonctionnent correctement pour les utilisations correctes de la readlink fonction.

Si vous avez votre chemin dans un std::string, vous pourriez faire quelque chose comme ceci:

#include <unistd.h>
#include <limits.h>

std::string do_readlink(std::string const& path) {
    char buff[PATH_MAX];
    ssize_t len = ::readlink(path.c_str(), buff, sizeof(buff)-1);
    if (len != -1) {
      buff[len] = '#include <unistd.h>
#include <limits.h>
std::string do_readlink(std::string const& path) {
char buff[PATH_MAX];
ssize_t len = ::readlink(path.c_str(), buff, sizeof(buff)-1);
if (len != -1) {
buff[len] = '\0';
return std::string(buff);
}
/* handle error condition */
}
';
      return std::string(buff);
    }
    /* handle error condition */
}

Si vous êtes seulement au bout d'un chemin fixe:

std::string get_selfpath() {
    char buff[PATH_MAX];
    ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff)-1);
    if (len != -1) {
      buff[len] = 'std::string get_selfpath() {
char buff[PATH_MAX];
ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff)-1);
if (len != -1) {
buff[len] = '\0';
return std::string(buff);
}
/* handle error condition */
}
';
      return std::string(buff);
    }
    /* handle error condition */
}

Pour l'utiliser:

int main()
{
  std::string selfpath = get_selfpath();
  std::cout << selfpath << std::endl;
  return 0;
}

Non, désolé, je pense que je n'ai pas ma phrase phrase correctement. Je n'ai pas le chemin, je suis à l'aide de readlink("/proc/self/exe", buf, bufsize); correctement afin de le récupérer.
Je ne comprends pas ce que vous dites. Merci d'éditer votre question afin de montrer ce que vous avez, et un exemple de ce que vous voulez.
ok, j'ai mis plus de détails, mais ma réponse originale à cette question plutôt bien fonctionné avec un chemin fixe...
Juste pour ajouter quelques détails sur lesquels j'ai été un peu en difficulté: le get_selfPath() fonction renvoie le chemin d'accès, y compris le nom de l'exécutable. Pour obtenir juste le chemin de retirer le nom de l'exécutable, vous pouvez effectuer les opérations suivantes: std::string::size_type t = path.find_last_of("/") et puis path = path.substr(0,t). Je ne sais pas pourquoi, partout, ce n'est jamais explicitée assez;)
ce n'est pas une faute de frappe à tous.
quelle devrait être la valeur de l'argument de la fonction do_readlink?
Je ne pense pas que c'est une bonne idée de l'être cavalier sur l'affectation 4KiB sur la pile comme ça. Pourquoi pas une std::vector?
Vous n'avez pas besoin d'ajouter de déconner avec l'ajout d'un terminateur null. Il suffit d'écrire if (len != -1) { return std::string(buff, static_cast<size_t>(len)); }

InformationsquelleAutor Mat

Regardons ce la page de manuel dit:

 readlink() places the contents of the symbolic link path in the buffer
 buf, which has size bufsiz.  readlink does not append a NUL character to
 buf.

OK. Devrait être assez simple. Compte tenu de votre tampon de 1024 caractères:

 char buf[1024];

 /* The manpage says it won't null terminate.  Let's zero the buffer. */
 memset(buf, 0, sizeof(buf));

 /* Note we use sizeof(buf)-1 since we may need an extra char for NUL. */
 if (readlink("/proc/self/exe", buf, sizeof(buf)-1) < 0)
 {
    /* There was an error...  Perhaps the path does not exist
     * or the buffer is not big enough.  errno has the details. */
    perror("readlink");
    return -1;
 }

ne devrait pas être... si (readlink("/proc/self/exe", buf, sizeof(buf)-1) <0) ?
if (readlink(/*...*/)) tests de non-nulle. Moins de 0 est différent de zéro.
readlink de retour >0 en cas de succès. "En cas de succès, readlink() renvoie le nombre d'octets placés dans buf. En cas d'erreur, -1 est renvoyé". linux.die.net/man/2/readlink.
Ok. Modifier ensuite. C'est un peu inhabituel pour un syscall. Habituellement, 0 est un succès.

InformationsquelleAutor asveikau

Accepté réponse est presque correct, sauf que vous ne pouvez pas compter sur PATH_MAX parce que c'est

de ne pas être défini par POSIX si le système ne dispose pas de tels
de limite.

(À partir de readlink(2) page de manuel)

Aussi, lorsqu'il est défini, il n'est pas toujours le reflet de la "vraie" limite. (Voir http://insanecoding.blogspot.fr/2007/11/pathmax-simply-isnt.html )

La readlink la page de manuel donne aussi une façon de le faire que sur lien symbolique :

De manière statique à l'aide d'un tampon de taille peut ne pas fournir suffisamment d'espace pour le
lien symbolique contenu. La taille de la mémoire tampon peut être
obtenu à partir de la stat.st_size valeur retournée par un appel à lstat(2) sur
le lien. Cependant, le nombre d'octets écrits par readlink() et en lecture
linkat() doit être vérifié pour s'assurer que la taille de la symbolique
le lien n'a pas augmenté entre les appels.

Toutefois, dans le cas de /proc/self/exe comme pour la plupart de /proc fichiers, stat.st_size serait de 0. La seule solution que je vois est pour redimensionner tampon alors qu'il ne rentre pas.

Je suggère l'utilisation de vector<char> à suivre à cette fin:

std::string get_selfpath()
{
    std::vector<char> buf(400);
    ssize_t len;

    do
    {
        buf.resize(buf.size() + 100);
        len = ::readlink("/proc/self/exe", &(buf[0]), buf.size());
    } while (buf.size() == len);

    if (len > 0)
    {
        buf[len] = 'std::string get_selfpath()
{
std::vector<char> buf(400);
ssize_t len;
do
{
buf.resize(buf.size() + 100);
len = ::readlink("/proc/self/exe", &(buf[0]), buf.size());
} while (buf.size() == len);
if (len > 0)
{
buf[len] = '\0';
return (std::string(&(buf[0])));
}
/* handle error */
return "";
}
';
        return (std::string(&(buf[0])));
    }
    /* handle error */
    return "";
}

InformationsquelleAutor Wddysr

char *
readlink_malloc (const char *filename)
{
  int size = 100;
  char *buffer = NULL;

  while (1)
    {
      buffer = (char *) xrealloc (buffer, size);
      int nchars = readlink (filename, buffer, size);
      if (nchars < 0)
        {
          free (buffer);
          return NULL;
        }
      if (nchars < size)
        return buffer;
      size *= 2;
    }
}

Prises à partir de: http://www.delorie.com/gnu/docs/glibc/libc_279.html

InformationsquelleAutor onelineproof

Vous devez vous connecter pour publier un commentaire.