Bonjour,
Je souhaitais faire cette exercice et je me suis renseigner, en effet chmod permet d'attribuer des droits à certains "personne" (U : user , G : group , o : other, a = ?)
 
En effet chmod peut s'écrire sous ligne de commande suivante :
 
> chmod -u 777
 
Le premier "chiffre" signifie le droit de lire (read)
Le second "chiffre" signifie le droit d'écrire (write)
Et enfin le dernier signifie le droit d'éxécuter
 
Et ce premier groupe de chiffres à savoir 111 qui représente le premier 7 de votre chmod 777 donne tout les droits (r,w,x --> read, write, execute) au propriétaire du fichier et le deuxieme 7 de même pour le groupe de ce propriétaire et finalement le dernier 7 les même droits pour les autres.
 
Hors j'aimerais implémenter la commande chmod avec les notations en lettres ([ugoa][[+-=][rwx]) mais pas celle en octale. Et ma commande, comme chmod, pourra s’appliquer à un ou plusieurs fichiers.
Comment puis-je faire?
 
Merci d'avance.

tu fais un mapping
r = 1, w = 2, x = 4
et tu parcours ta chaine qui contient des rwx et tu ajoute la valeur mappé

Ta phrase ne veut rien dire. Le 111 ne représente pas le premier 7.
Dans le chmod octal, le nombre écrit xyz se décompose en 3 chiffres x; y et z.
Le chiffre x pouvant aller de 0 à 7 sera les droits que le propriétaire du fichier aura sur le fichier
Le chiffre y pouvant aller de 0 à 7 sera les droits que le groupe du fichier aura sur le fichier
Le chiffre z pouvant aller de 0 à 7 sera les droits que les autres (ceux qui ne sont ni propriétaire ni groupe) auront sur le fichier
Chaque chiffre de 0 à 7 se décompose en
0 = rien
1 = droit en exécution
2 = droit d'écriture
3 = 2 + 1 = droit d'écriture + exécution
4 = droit de lecture
5 = 4 + 1
6 = 4 + 2  
7 = 4 + 2 + 1
 

Ben tu analyses la chaine reçue par ton programme. Tu commences par chercher +=-, tu regardes ce qu'il y a avant, tu regardes ce qu'il y a après. Bref tu fais marcher ta tête quoi.
 
PS: la commande chmod accepte aussi plusieurs instructions séparées par une virgule style chmod ug+r,o-w. Donc il vaudra mieux créer une fonction chargée d'analyser chaque groupe lettre+=-lettre et d'appliquer la fonction pour chaque groupe1,groupe2,groupe3...

Peux tu détailler ce que tu veux dire par mapping?
 
Moi j'avais pensé à un appel système avec stat () ?

Ben tu parcours ta chaine. Quand tu rencontres r, tu fais "+4"; quand tu rencontres "w", tu fais "+2" et quand tu rencontres "x" tu fais "+1". Le résultat final te donne la valeur à positionner.
 

stat te donnera les droits actuels, rien de plus

Bonjour, j'ai pu depuis travailler sur le code et me voilà à nouveau coincé, voici le code complet que je n'arrive pas à faire le décalage de bit avec la fonction val_binaire , celle ci n'est pas utiliser mais devrait l'être je pense pour changer les droits. Pouvez vous m'aidez ?
Merci
 
Le code:
     //Fonction qui retourne les droits en octal. La chaine droits contient au plus 3 caracteres (du type "rw" ou "r" ou "rwx", etc.).
    //Cette fonction est deja code dans le code que je vous ai renvoye.
    int retourneDroitsOctal(char* droits)
    {
 
    //On initialise val à 0
    int val=0, i;
 
       for(i=0; i <strlen(droits); i++)
       {
          switch(droits[i])  //MODIFIER
          {
             //AB: On rajoute 4 a val si r est dans la chaine 'droits'
             case 'r': val += 4;  
                break;
             //AB: On rajoute 2 a val si w est dans la chaine 'droits'
             case 'w': val += 2;  
                break;
             //AB: On rajoute 1 a val si x est dans la chaine 'droits'
             case 'x': val += 1;  
                break;
             default: fprintf(stderr,"Argument invalide : %s",droits);
                exit(1);
                break;
          }
       }
 
       return val;
    }
 
    //Fonction qui change les droits (le mode) pour un utilisateur particulier.
    //Cet utilisateur est designe par le caractere 'qui' qui vaut 'u' ou 'g' ou 'o' mais ne peut pas valoir 'a'.
    //'type' designe si on ajoute ou retire les droits, les valeurs possibles sont '+' ou '-' ou '='.
    //Cette fonction est deja aussi plus ou moins deja code dans le programme que vous m'avez envoye.
    //Renvoi -1 en cas d'erreur.
    int changeDroitQui(const char* qui, char type, int droitOctal, const char* nomFichier)
    {
     int val;
       int mask;
       struct stat buf;
       int pval;
       if((lstat(nomFichier, &buf)) == -1)
       {
          perror("Impossible de donnée les droits : " );
       }
 
       
       pval = buf.st_mode; // récupérer les droits
       switch(*qui)
       {
          case 'u': val = 6;  
             break;
          case 'g': val = 3;  
             break;
          case 'o': val = 0;  
             break;
          //AB: Pour a c'est tous il faut donc modifier les droits pour 'g', 'o' et 'u'.
          case 'a': val = 3;
             break;
          default: perror("1er argument faux : " );
             break;
       }
 
       
       switch(type)
       {
          case '+': val = pval | (droitOctal << val);  // rwx --> droitoctal  puiss --> val
             break;
          case '-': mask = pval & (droitOctal << val);
               val = pval-mask;  
             break;
          //case '=': val = modif(pval, droitOctal, val);  Test mis en commentaire fonction modif manquante
             //break;
          default: perror("2ieme argument faux : " );
             break;
       }
 
       //val = 0;
       return val;    
 
    }
 
 
    //// Fonction de décalage de bit val --> pval
    void val_binaire(int val)
    {
 
       int i, q, r;
       int gr = 0;
       int *pt = NULL;
       int voir;
 
       voir = val;
       pt = (int *)malloc(4*sizeof(int));
       while(q != 0  )
       {
          q= voir/2;
          voir/=2;
          gr++;
       }
 
       pt = (int *)malloc((gr+1)*sizeof(int));
       gr = 0;
       q=1;
       
       while(q != 0  )
       {
          q= val/2;
          r=val%2;
          val/=2;
          pt[gr] = r;
          gr++;
       }
 
       printf("|| " );
       for(i=gr-1; i>=0; i--)
       {
          printf("%d", pt[i]);
          if((i)%3 == 0) printf(" " );
       }
 
       printf("|| \n" );
    }
    ////
 
 
 
    //Fonction qui change les droits pour l'ensemble des utilisateurs specifie. Je vous donne le code.
    void changeDroit(const char* argument, const char* nomFichier)
    {
       int i,j, droitOctal;
       char qui[4], type, droits[4], c;
       
       i=0;j=0;
       if(strlen(argument)<3){
          fprintf(stderr,"Erreur argument invalide (%s)\n",argument);    
          exit(2);
       }
 
       //Mise a jour de la liste des utilisateurs a qui on change les droits (aoug, etc.)
       while(i<3){
          c=argument[i];
          if((c=='a')||(c=='o')||(c=='u')||(c=='g')){
             qui[i]=c;
             i++;
          }else{
             if((i>=1)&&(c=='-')||(c=='+')||(c=='=')) break;
             fprintf(stderr,"Erreur argument: %s n'est pas un argument correcte\n",argument);
             exit(2);
          }
       }//fin du for sur i
       
       //On n'oublie pas le caractere de fin de chaine
       qui[i]='\0';
 
       //Mise a jour du type d'assignation ('+', '-' ou '=')
       c=argument[i];
       if((c=='-')||(c=='+')||(c=='=')) type=c;
       else{
          fprintf(stderr,"Erreur argument: %s n'est pas un argument correcte (+)\n",argument);
          exit(2);
       }
       
       //A vous de remplir correctement la chaine "droits" sur le meme principe...
       
       ///////AJOUTER
       //Mise a jour de la liste des droits pour le(s) utilisateur(s) (rwx, etc.)
       
       printf("avant i : %d \n",i);
       i++; // Incrémentation du compteur sur la première lettre des droits ( r , w , x)
       printf("apres i : %d \n",i);
 
       while(j<3){
          c=argument[i];
          if((c=='r')||(c=='w')||(c=='x')){
             droits[j]=c;
             i++;j++;
          }else{
             if((j>=1)&&(c=='\0')) break;
             fprintf(stderr,"Erreur argument: %s n'est pas un argument correcte (rwx) \n",argument);
             exit(2);
          }
       } //Fin du while
 
       //On n'oublie pas le caractere de fin de chaine
       droits[j]='\0';
 
       
       //DEBUG (il faudra retirer les deux lignes du dessous).
       //strcpy(droits,"" );
       fprintf(stderr,"droits=%s qui=%s type=%c fichier=%s\n",droits,qui,type,nomFichier);
 
       //Il n'y a plus qu'a faire le changement de droit
       droitOctal=retourneDroitsOctal(droits);
       if(changeDroitQui(qui, type, droitOctal, nomFichier)==-1){
          fprintf(stderr,"Erreur changeDroitQui()\n" );
          exit(1);
       }
 
 
    }
 
    int main(int argc, char* argv[])
    {
 
       //Verification du nombre d'arguments
       if (argc < 2) perror ("erreur du nombre d'argument : doit être supérieur ou égal à 3" );
 
       //Appel de la fonction changeDroit sur tous les fichiers specifies..
       //changeDroit(
       
 
       //MODIFIER  A VOIR RECUPERER LES DROITS
       fic = buf.st_mode; // récupérer les droits
       
       
       //La ligne du dessous sert au debug, il faut la modifier
       changeDroit(argv[1],"teste.txt" );
 
       return(0);
    }

Ca c'est du commentaire !!! Et en plus super utile pour qui ne comprend pas l'instruction "int val=0"...

C'est mal. on ne sort par exit que du main. Un programme c'est des poupées russes. Toute fonction appelée doit retourner vers l'appelant. S'il y a un problème, lui prendra une décision. Il renverra vers son appelant à lui par exemple...
 

Je ne vois pas pourquoi la variable "qui" est un pointeur sur un char vu que tu ne modifies pas sa valeur. De plus, si le stat () ne fonctionne pas tu affiches un message mais tu continues qd-même inutilement la fonction.
 

int pt[4] !!!

T'as initialisé q ???

Deux divisions par 2. Tu places voir/=2 en premier et ensuite q=voir

while (val != 0)
{
    pt[gr++]=val%2;
    val/=2;
}
 

C'est pas mal les parenthèses autour de i. C'est utile au cas où le compilo ne connaitrait pas la priorité de "pas d'opérateur" par rapport à l'opérateur "modulo"...

Quand tu veux tu libères la mémoire allouée dans ta fonction !!!
 

Idem première remarque. J'arrête là.