Bonjour tous,
Je vous prie de bien vouloir m'aider.
J'ai une fonction appelée fonctde(paramètre) qui me retourne un nombre et je voudrais l'utiliser dans une autre fonction. Comment faire pour l'appeler?
Piste: exec, system mais je n'en suis pas sure et je ne connais pas la syntaxe exacte.
Merci pour votre attention et votre aide.

je ne comprends pas trop ton problème : il n'y a rien de spécial à faire pour appeler une fonction C depuis une autre fonction C:

 
la fonction system() sert à appeler une commande externe à ton programme, comme tu pourrais le faire dans un shell.

la fonction exec() est un peu plus compliquée et je ne suis pas sûr que ce soit de ton niveau encore. (man exec si tu veux quand même des détails)

man exec ne donne rien. Mon programme n'a-t-il pas besoin que je lui mentionne que je vais utiliser une fonction déjà existante?
merci.
Penses-tu que 'cat /proc/pid/status' soit un fichier?
Comment récupérer le résultat?
Peut-on écrire res = "cat /proc/pid/status"?
Merci

En unix, tout est fichier.
 
Non,tu ne peux pas écrire

 
A priori si c'est pour faire ce genre de traitement, des scripts shell semblent plus adaptés qu'utiliser le langage C.

Donc si tout est fichier alors je peux utiliser directement 'fopen'?
Le problème, je l'ai déjà fait mais ça ne marche pas.

en fait j'ai déjà utilisé 'fopen' pour ouvrir les fichiers. l'erreur est que le système ne connait pas le chemin.
Merc

question de droits peut etre ?

 
bon
mentre ton code.  

Voici mon code
 
#include<stdio.h>
#include<string.h>
#include <stdlib.h>
 
/*Lecture de /proc*/
 
//Définition du type du tableau des pid
typedef struct {
   int nb1;
   int nb2;
   char t1[40];
   char t2[40];
   char t3[40];
   char t4[40];
     }bloc;
             
//==============================================================================
//
//------------------------------------------------------------------------------            
//nombre de lignes du fichier lu
int nblignefichier(char arg2[40])
   {
   int n = 0; /* nombre de lignes lues */
   char ligne[256];
   FILE *f = fopen( arg2, "r" ); /* ouvre en lecture */
   if (f==NULL) {
     printf("erreur ouverture\n" );
     return 0;        /* sort du programme (code erreur 1) */
   }
   while (fgets( ligne, 256, f ) != NULL) { /* essai lecture ligne */
       n++;                                  
   }
   fclose(f);  /* ferme le fichier */
   return n;
  }
//exec("pidof  " );  
//==============================================================================
//
//------------------------------------------------------------------------------
// Création du tableau des processus importants
       
        //nombre de lignes du tableau des processus importants
      int nblignetab(char * process1[20])
      {
          int nb;
          nb=0;
          while (process1[nb]!=NULL)
          {
                nb++;
          }
                return nb;
      }
  //==============================================================================
//
//------------------------------------------------------------------------------
//afficher le tableau des processus importants????
void affichprocess(char * process2[20])//utiliser int main void???
{      
         
         int i, nb;
         nb = nblignetab(process2);
         for (i=0; i<nb; i++)  
         {
           printf ("%s\n", process2[i]);
         }
           
   
}
//==============================================================================
//
//------------------------------------------------------------------------------
/*Déterminer les pid des processus importants*/
int pidde(char * process3[20])
{
int i,nb;
int pidde[20];
nb=nblignetab(process);
for (i=0; i<nb; i++)
     {
    pidde[i] = pidof(process[i]);
     }    
return pidde;
}
 
//==============================================================================
//
//------------------------------------------------------------------------------
/*Vérifier si les pid de pidde sont dans /proc*/
int verif(bloc *b,int pidde[20],int taille)
{
int tmp,i,j;
int erreurpid[nb];
nb = nblignetab(pidde);
int erreurpid[20];
 
for(i=0;i<nb;i++)
{
  erreurpid[i]=0;
}
 
for (i=0; i<nb; i++)
    {
          tmp = pidde[i];
          for (j=0; j<taille; j++)
          {
              if (tmp == b[j].nb1)// || (tmp == b[j].nb2))
              {
                return 1;
              }
          }
           for(j=0;j<taille;j++)
           {
              if (tmp == b[j].nb2)
              {
                return 1;
              }                                  
           }
            n1 = atoi(b[0].t1);
            n2 = atoi(b[0].t2);
             
        //    if (tmp == n1)
//              {
//                return 1;
//              }
//            if (tmp == n2)
//              {
//                return 1;
//              }          
           printf("Ce processus ne fonctionne pas" );
           erreurpid[i]=tmp;
           
     }
             
  return erreurpid;        
     
}
//==============================================================================
//
//------------------------------------------------------------------------------
int main(void)
{
int pidde1[20];
int erreurpid1[20];
int i,a,taille,pos1,j,nb;
char *process[20]= {"mysql","apache","bash","blabla","blabla1"} ;//liste de tous les processus importants
 
 pidde1=pidde(process);
 
/*Ouvrir le fichier en lecture seule*/
FILE* lecture = fopen("/proc","r" );
taille = nblignefichier("/proc" );
 
//création du tableau de taille "taille"
bloc b[taille];
 
char nb[255];
 
//remplissage du tableau
for(i=0;i<taille;i++)
{
 fscanf(lecture, "%s", &nb);
 b[i].nb1 = atoi(nb);
 fscanf(lecture, "%s", &nb);
 b[i].nb2 = atoi(nb);
 fscanf(lecture, "%s", &b[i].t1);
 fscanf(lecture, "%s", &b[i].t2);
    fscanf(lecture, "%s", &b[i].t3);
    fscanf(lecture, "%s", &b[i].t4);
   
 
}
/* pclose(fichier);*/
fclose(lecture);
 
 //affichage du tabeau
 for(i=0;i<taille;i++)
 {
 printf("%d %d %s %s %s %s\n",b[i].nb1,b[i].nb2,b[i].t1,b[i].t2,b[i].t3,b[i].t4);
 }
 
 erreurpid1=verif(b,pidde1,taille);
 
 
 system("PAUSE" );
 
// la 1ere colonne s'obtient avec b[i].nb1
// la 2e colonne s'obtient avec b[i].nb2
return EXIT_SUCCESS;
 
}
 
 
//Donner le statut des processus les plus importants
 
int i, nb;
nb = nblignetab(pidde);
for (i=0; i<nb; i++)
{
     res = "/proc/pidde[i]/status";//syntaxe???
}
 
 
   
 
 

balise [code] stp

C'est quoi ?
balise [code] stp

exemple:
 
[ code ] code [ / code ] =>

 
et ca évite les smileys intempestifs, c'est plus lisible.

fopen() permet uniquement d'ouvrir un fichier à partir de son nom dans le filesystem (en gros, ça concerne les fichiers que tu peux voir en faisant un 'ls', ce qui inclut déjà des fichiers "bizarres" ).
 
Mais la notion de fichier est beaucoup plus générale dans le monde unix. N'importe quel flux ordonné de données peut être considéré comme un fichier (et d'ailleurs tu ne fais naturellement pas de différence entre le flux de données provenant d'un clavier ou d'un fichier). Tu peux utiliser ceci pour faire communiquer entre eux plusieurs processus (c'est ce qui est fait par ton shell quand tu lances par exemple une commande du genre "cat /proc/pid/status | grep ..." : il s'agit simplement de connecter le flux de sortie du premier processus au flux d'entrée du deuxième à travers un pipe)
pour faire ça en C, il y a plein de moyens. L'un d'entre eux (peut-être le plus simple) étant d'utiliser popen() qui fonctionne un peu comme fopen() :

 
 
Mais _darkalt3_ a raison : suivant ce que tu veux faire, il peut être beaucoup plus intéressant de faire du script shell ou perl ou quelque chose du genre...

Je ne connais pas perl encore moins shell. Je connais C et je débute. Je vais essayer de me renseigner sur perl.
Merci pour les infos.

si tu connais "cat", saches qu'un script shell est composé de ce genre de commandes, soit les commandes unix. Ca ne devrait pas te poser trop de problèmes.

Bonjour,
peut-on faire ceci dans un programme C:
cp /proc/partitions  /root/partitions
Partitions étant un fichier du répertoire /proc.
Le but étant d'utiliser partitions comme un fichier .txt par exemple.
En effet, lorsque j'ouvre /proc/partitions à partir du 'Secure Shell' il n'y a rien à l'intérieur. Mais quand je le copie dans /root, le contenu apparaît comme par magie!!!
Je ne comprends pas trop.
Merci

J'ai fait:
system("fichier_source> fichier.dat" ) et ça marche.
Mais je n'arrive pas à l'utiliser.
Merci

Tu pourrais être moins précis, parce là avec tous ces détails, on est perdu ...
 
Utiliser quoi ? fichier.dat ? Il suffit que l'application appelante ouvre le fichier et lise les données. C'est dur ?

plus exactement system("cat /etc/network/interfaces > /root/interfaces.dat" )
Cela me permet d'utiliser le fichier "interfaces" dans et d'en extraire des informations. Cela marche très bien. Mais en fonction du résultat de 'cat /etc/network/interfaces'  le programme que j'aie fait ne marche pas car apparement le fichier /root/interfaces n'est pas sous la même forme de présentation et je ne sais pas comment faire pour voir le contenu de /root/interfaces.
Je crois que je suis un peu naze, je dois passer à côté de méthodes simples. Merci de votre aide.

pourquoi tu ne lis pas directement ton fichier /etc/network/interfaces ?

et pourquoi en C

tant que tu ne nous diras pas quelle est la finalité de tout ça, je persisterai à penser que le script est plus adapté (même si tu n'y connais rien, c'est pas très compliqué à apprendre et on peut faire tout un tas de choses compliquées, même avec des connaissances de base)

Je ne peux pas lire directement car cela me met"accès introuvable". En C car c'est le seul langage que je connaisse.
Merci

Je vais apprendre donc. Mais où trouver les enseignements névessaires?

google

OK, merci