Bonjour,
J'ai d'abord pos=E9 la question sur fr.comp.lang.c, mais il semble que
le probl=E8me soit li=E9 au syst=E8me.
Je la repose donc sur ce NG plus appropri=E9 :
Je souhaite cr=E9er une API (sous AIX) fournissant 2 fonctions :int
f1(arg1); et int f2(arg1);
Ces deux fonctions sont =E9crit dans un fichier api.c (et api.h).
Le probl=E8me c'est que c'est deux fonctions sont assez cons=E9quentes,
et donc font appel =E0 d'autres sous fonctions d=E9fini dans source.c (et
le fichier d'entete source.h).
Le probl=E8me c'est que si je cr=E9e une librairie de la mani=E8re
suivante :
ar r api api.o source.o
et
ranlib api
Lorsque je livrerai la librairie libapi on pourra utiliser les
fonctions f1, f2 mais aussi mes sous fonctions. Au d=E9part j'avais tout
mis dans le m=EAme fichier et mis les sous fonctions comme "static",
mais le fichier devient trop grand.
Comment puis-je faire pour que seul les fonctions souhait=E9es soit
r=E9utilisables ? Au d=E9part je pensais fournir que le api.h, comme =E7a
les utilisateurs ne connaissant pas les autres, =E0 priori ils ne les
utiliseront pas. Mais se n'est pas tr=E8s rigoureux.
J'ai eu pour r=E9ponse :
Tu mets toutes tes fonctions annexes dans des sources s=E9par=E9s et tu
les
places dans une biblioth=E8que. Ensuite tu prends ton source avec tes 2
fonctions et tu fais une =E9dition de lien partiel avec ta
biblioth=E8que. Il ne
restera en extern que tes fonctions. Regarde la doc de ton linker.
J'ai donc essay=E9. Mais j'ai toujours le probl=E8me.
J'ai compil=E9 mon fichier annexe et mis dans la librairie libannexe.a
Je compile mon api avec : cc -o api.o -lannexe -c api.c
Mais dans api.o, les fonctions contenus dans libannexe.a sont toujours
utilisable =E0 l'exterieur.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Nicolas George
"xdunat" wrote in message :
Au départ je pensais fournir que le api.h, comme ça les utilisateurs ne connaissant pas les autres, à priori ils ne les utiliseront pas. Mais se n'est pas très rigoureux.
C'est ce qui se fait un peu partout, en tout cas.
Tu mets toutes tes fonctions annexes dans des sources séparés et tu les places dans une bibliothèque. Ensuite tu prends ton source avec tes 2 fonctions et tu fais une édition de lien partiel avec ta bibliothèque. Il ne restera en extern que tes fonctions. Regarde la doc de ton linker.
J'ai donc essayé. Mais j'ai toujours le problème. J'ai compilé mon fichier annexe et mis dans la librairie libannexe.a Je compile mon api avec : cc -o api.o -lannexe -c api.c Mais dans api.o, les fonctions contenus dans libannexe.a sont toujours utilisable à l'exterieur.
Ou est le problème ?
C'est plus compliqué que ça. Je ne l'ai jamais fait, le seul endroit où j'ai vu faire ça, c'est la glibc, et bon courage pour comprendre comment ça s'organise ; il y a probablement d'autres exemples.
"xdunat" wrote in message
<1168006283.533597.184910@s34g2000cwa.googlegroups.com>:
Au départ je pensais fournir que le api.h, comme ça
les utilisateurs ne connaissant pas les autres, à priori ils ne les
utiliseront pas. Mais se n'est pas très rigoureux.
C'est ce qui se fait un peu partout, en tout cas.
Tu mets toutes tes fonctions annexes dans des sources séparés et tu
les
places dans une bibliothèque. Ensuite tu prends ton source avec tes 2
fonctions et tu fais une édition de lien partiel avec ta
bibliothèque. Il ne
restera en extern que tes fonctions. Regarde la doc de ton linker.
J'ai donc essayé. Mais j'ai toujours le problème.
J'ai compilé mon fichier annexe et mis dans la librairie libannexe.a
Je compile mon api avec : cc -o api.o -lannexe -c api.c
Mais dans api.o, les fonctions contenus dans libannexe.a sont toujours
utilisable à l'exterieur.
Ou est le problème ?
C'est plus compliqué que ça. Je ne l'ai jamais fait, le seul endroit où j'ai
vu faire ça, c'est la glibc, et bon courage pour comprendre comment ça
s'organise ; il y a probablement d'autres exemples.
Au départ je pensais fournir que le api.h, comme ça les utilisateurs ne connaissant pas les autres, à priori ils ne les utiliseront pas. Mais se n'est pas très rigoureux.
C'est ce qui se fait un peu partout, en tout cas.
Tu mets toutes tes fonctions annexes dans des sources séparés et tu les places dans une bibliothèque. Ensuite tu prends ton source avec tes 2 fonctions et tu fais une édition de lien partiel avec ta bibliothèque. Il ne restera en extern que tes fonctions. Regarde la doc de ton linker.
J'ai donc essayé. Mais j'ai toujours le problème. J'ai compilé mon fichier annexe et mis dans la librairie libannexe.a Je compile mon api avec : cc -o api.o -lannexe -c api.c Mais dans api.o, les fonctions contenus dans libannexe.a sont toujours utilisable à l'exterieur.
Ou est le problème ?
C'est plus compliqué que ça. Je ne l'ai jamais fait, le seul endroit où j'ai vu faire ça, c'est la glibc, et bon courage pour comprendre comment ça s'organise ; il y a probablement d'autres exemples.
patrice
"xdunat" a écrit dans le message de news:
plein de chose ...
je crois pas que ca soit lié au systeme. tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
par contre rien n'empeche de magouiller. perso je laisserais les fonctions statiques (vu que c'est le but) et je chercherais a les appeler et donc sans passer par l'édition de lien. une solution possible serait d'utiliser des pointeurs de fonctions
gros module privé
static function fun1() { ... } static function fun2() { ... }
function gateway( int qui) { switch (qui) { case 0: return fun1; case 1: return fun2; ... }
================ petit module publique :
function publique1() { fun1=gateway(0); fun1(); }
apres, si on peut faire un mode parano si on a peur du rétro engeneering
function gateway(int qui1,int qui2,int qui3) { hashÊlchash(qui1,qui2,qui3); // savant calcul quelconque, dont le résultat est connu à l'avance, switch (hash) case 0x522451412: return fun1; case 0xAA112158: return fun2; default:: return rnd(); }
"xdunat" <xavier.dunat@worldonline.fr> a écrit dans le message de
news:1168006283.533597.184910@s34g2000cwa.googlegroups.com...
plein de chose ...
je crois pas que ca soit lié au systeme.
tu peux faire communiquer 2 module que par des fonctions publiques.
par définition, une fonction privée est privée, l'extérieur n'y a pas acces,
et ca vaut aussi pour le développeur :)
par contre rien n'empeche de magouiller.
perso je laisserais les fonctions statiques (vu que c'est le but) et je
chercherais a les appeler et donc sans passer par l'édition de lien.
une solution possible serait d'utiliser des pointeurs de fonctions
gros module privé
static function fun1()
{
...
}
static function fun2()
{
...
}
function gateway( int qui)
{
switch (qui) {
case 0: return fun1;
case 1: return fun2;
...
}
================ petit module publique :
function publique1()
{
fun1=gateway(0);
fun1();
}
apres, si on peut faire un mode parano si on a peur du rétro engeneering
function gateway(int qui1,int qui2,int qui3)
{
hashÊlchash(qui1,qui2,qui3); // savant calcul quelconque, dont le
résultat est connu à l'avance,
switch (hash)
case 0x522451412: return fun1;
case 0xAA112158: return fun2;
default:: return rnd();
}
je crois pas que ca soit lié au systeme. tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
par contre rien n'empeche de magouiller. perso je laisserais les fonctions statiques (vu que c'est le but) et je chercherais a les appeler et donc sans passer par l'édition de lien. une solution possible serait d'utiliser des pointeurs de fonctions
gros module privé
static function fun1() { ... } static function fun2() { ... }
function gateway( int qui) { switch (qui) { case 0: return fun1; case 1: return fun2; ... }
================ petit module publique :
function publique1() { fun1=gateway(0); fun1(); }
apres, si on peut faire un mode parano si on a peur du rétro engeneering
function gateway(int qui1,int qui2,int qui3) { hashÊlchash(qui1,qui2,qui3); // savant calcul quelconque, dont le résultat est connu à l'avance, switch (hash) case 0x522451412: return fun1; case 0xAA112158: return fun2; default:: return rnd(); }
Nicolas George
"patrice" wrote in message <459e60fe$0$9715$:
je crois pas que ca soit lié au systeme.
C'est fortement lié au format des binaires.
tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître ou pas dans la table des symboles publics. Et ça, il y a des outils pour la manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien documenté et lissé.
une solution possible serait d'utiliser des pointeurs de fonctions
Et se taper une indirection, avec tout le coût que ça peut impliquer.
"patrice" wrote in message <459e60fe$0$9715$426a34cc@news.free.fr>:
je crois pas que ca soit lié au systeme.
C'est fortement lié au format des binaires.
tu peux faire communiquer 2 module que par des fonctions publiques.
par définition, une fonction privée est privée, l'extérieur n'y a pas acces,
et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître
ou pas dans la table des symboles publics. Et ça, il y a des outils pour la
manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien
documenté et lissé.
une solution possible serait d'utiliser des pointeurs de fonctions
Et se taper une indirection, avec tout le coût que ça peut impliquer.
tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître ou pas dans la table des symboles publics. Et ça, il y a des outils pour la manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien documenté et lissé.
une solution possible serait d'utiliser des pointeurs de fonctions
Et se taper une indirection, avec tout le coût que ça peut impliquer.
Paul Gaborit
À (at) 05 Jan 2007 14:39:18 GMT, Nicolas George <nicolas$ écrivait (wrote):
"patrice" wrote in message <459e60fe$0$9715$:
je crois pas que ca soit lié au systeme.
C'est fortement lié au format des binaires.
tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître ou pas dans la table des symboles publics. Et ça, il y a des outils pour la manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien documenté et lissé.
Ceci étant, si quelqu'un est capable d'aller chercher dans une bibliothèque les points d'entrée public non documentés par le fichier d'entête, il n'a pas beaucoup plus à faire pour trouver les points d'entrée des fonctions statiques...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
À (at) 05 Jan 2007 14:39:18 GMT,
Nicolas George <nicolas$george@salle-s.org> écrivait (wrote):
"patrice" wrote in message <459e60fe$0$9715$426a34cc@news.free.fr>:
je crois pas que ca soit lié au systeme.
C'est fortement lié au format des binaires.
tu peux faire communiquer 2 module que par des fonctions publiques.
par définition, une fonction privée est privée, l'extérieur n'y a pas acces,
et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître
ou pas dans la table des symboles publics. Et ça, il y a des outils pour la
manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien
documenté et lissé.
Ceci étant, si quelqu'un est capable d'aller chercher dans une
bibliothèque les points d'entrée public non documentés par le fichier
d'entête, il n'a pas beaucoup plus à faire pour trouver les points
d'entrée des fonctions statiques...
--
Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
À (at) 05 Jan 2007 14:39:18 GMT, Nicolas George <nicolas$ écrivait (wrote):
"patrice" wrote in message <459e60fe$0$9715$:
je crois pas que ca soit lié au systeme.
C'est fortement lié au format des binaires.
tu peux faire communiquer 2 module que par des fonctions publiques. par définition, une fonction privée est privée, l'extérieur n'y a pas acces, et ca vaut aussi pour le développeur :)
La distinction entre privé et public, c'est uniquement le fait d'apparaître ou pas dans la table des symboles publics. Et ça, il y a des outils pour la manipuler. Mais comme peu de monde s'en sert, ce n'est pas très bien documenté et lissé.
Ceci étant, si quelqu'un est capable d'aller chercher dans une bibliothèque les points d'entrée public non documentés par le fichier d'entête, il n'a pas beaucoup plus à faire pour trouver les points d'entrée des fonctions statiques...
-- Paul Gaborit - <http://perso.enstimac.fr/~gaborit/>
