[Resolu] [C Linux] poser un verrou sur un fichier

poser un verrou sur un fichier [Resolu] [C Linux] - C - Programmation

Marsh Posté le 23-10-2006 à 19:07:51    

Bonjour les cracks.
 
J'ai crée un programme pour me familiariser avec les verrous.
Mon mode opératoire est le suivant, je crée et verrouille un fichier "socket.tmp" dans le repertoire /tmp, puis je mets le programme en pause (getchar).
J'ouvre ce fichier avec l'éditeur vim et je tente d'écrire dessus pour vérifier que le verrou soit bien installé. Or je peux écrire sans problème sur le fichier alors qu'il devrait être vérrouillé.
 
Si j'ouvre le fichier en lecture seulement, le fcntl() ne veut pas le verrouiller en écriture, ce qui me laisse supposer que fcntl() tente bien la pose de verrou.
La fonction is_locked_socket() censée vérifier que le verrou est présent rapporte dans tous les cas que le fichier n'est pas verrouillé !
 
=> J'en conclu que fcntl() démarre la pose du verrou mais cette dernière n'aboutie pas. fcntl() ne renvoit pourtant aucun message d'erreur.
 
main.c

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <socket.h>
  4. #include <unistd.h>
  6. const char test[3]="ab";
  8. int main ( int argc , char** argv )
  9. {
  10. int fd;
  12. chdir ( "/tmp" );
  14. if ( ( fd = open_socket ( "socket.tmp" ) ) < 0 )
  15. {
  16.  printf ( "Cannot create socket file\n" );
  17.  exit ( -1 );
  18. }
  20. printf ( "Press <RETURN> to set lock\n" );
  21. getchar ();
  23. if ( lock_socket ( fd ) < 0 )
  24. {
  25.  printf ( "Cannot lock socket file\n" );
  26.  exit ( -1 );
  27. }
  29. lseek ( fd , 0 , SEEK_END );
  30. write ( fd , &test[0] , 2 );
  32. printf ( "Press <RETURN> to remove lock\n" );
  33. getchar ();
  35. if ( unlock_socket ( fd ) < 0 )
  36.  exit ( -1 );
  38. if ( close_socket ( fd ) < 0 )
  39.  exit ( -1 );
  41. exit ( EXIT_SUCCESS );


 
socket.c

Code :
  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include "socket.h"
  6. #include <stdio.h>
  8. //--------------------------------------------------------------------
  9. /* Function Name      : open_socket
  10. * Object             : Opens an existing socket or creates it !
  11. * Input Parameters   : [char*] path = Name of the socket file.
  12. * Output Parameters  : [int] = File descriptor of the socket file.
  13. *     '-1' if error.
  14. * Functions called   : open(),lseek().
  15. */
  16. //--------------------------------------------------------------------
  17. int open_socket ( char* path )
  18. {
  19. int err, fd;
  21. /* OPEN the file */
  22. fd = open ( path , O_RDWR | O_CREAT,
  23.      S_IRUSR | S_IWUSR );
  24. if ( fd < 0 )
  25.  return SOCKET_ERROR;
  27. /* JUMP at the beginning of the file */
  28. err = lseek ( fd , 0 , SEEK_SET );
  29. if ( err < 0 )
  30.  return SOCKET_ERROR;
  32. return fd;
  33. }
  35. //--------------------------------------------------------------------
  36. /* Function Name      : close_socket
  37. * Object             : Close an existing socket.
  38. * Input Parameters   : [int] fd = File descriptor of the socket file.
  39. * Output Parameters  : [int] = exit status.
  40. *     '-1' if error.
  41. *     '0' if no error.
  42. * Functions called   : close().
  43. */
  44. int close_socket ( int fd )
  45. {
  46. return close ( fd );
  47. }
  49. //--------------------------------------------------------------------
  50. /* Function Name      : unlock_socket
  51. * Object             : Unlock an existing socket.
  52. * Input Parameters   : [int] fd = File descriptor of the socket file.
  53. * Output Parameters  : [int] = exit status.
  54. *     '-1' if error.
  55. *     '0' if no error.
  56. * Functions called   : fcntl().
  57. */
  58. //-------------------------------------------------------------------
  59. int unlock_socket ( int fd )
  60. {
  61. static struct flock lock;
  63. lock.l_type = F_UNLCK;
  64. lock.l_whence = SEEK_SET;
  65. lock.l_start = 0;
  66. lock.l_len = 0;
  68. return fcntl ( fd , F_SETLKW , &lock );
  69. }
  71. //--------------------------------------------------------------------
  72. /* Function Name      : lock_socket
  73. * Object             : Lock an existing socket.
  74. * Input Parameters   : [int] fd = File descriptor of the socket file.
  75. * Output Parameters  : [int] = exit status.
  76. *     '-1' if error.
  77. *     '0' if no error.
  78. * Functions called   : fcntl().
  79. */
  80. //-------------------------------------------------------------------
  81. int lock_socket ( int fd )
  82. {
  83. static struct flock lock;
  85. lock.l_type = F_WRLCK;
  86. lock.l_whence = SEEK_SET;
  87. lock.l_start = 0;
  88. lock.l_len = 0;
  90. return fcntl ( fd , F_SETLKW , &lock );
  91. }
  93. //--------------------------------------------------------------------
  94. /* Function Name      : is_locked_socket
  95. * Object             : Check if an existing socket is locked.
  96. * Input Parameters   : [int] fd = File descriptor of the socket file.
  97. * Output Parameters  : [int] = exit status.
  98. *     the pid of the process if locked.
  99. *     '0' if unlocked.
  100. *     '-1' if error;
  101. * Functions called   : fcntl().
  102. */
  103. //-------------------------------------------------------------------
  104. int is_locked_socket ( int fd )
  105. {
  106. static struct flock lock;
  108. lock.l_type = F_WRLCK;
  109. lock.l_whence = SEEK_SET;
  110. lock.l_start = 0;
  111. lock.l_len = 0;
  113. if ( fcntl ( fd , F_GETLK , &lock ) == -1 )
  114.  return -1;
  116. if ( lock.l_type == F_UNLCK )
  117.  return 0;
  118. else
  119.  return lock.l_pid;
  120. }

Message cité 1 fois
Message édité par escaflownn le 25-10-2006 à 15:46:37
Reply

Marsh Posté le 23-10-2006 à 19:07:51   

Reply

Marsh Posté le 24-10-2006 à 21:36:40    

J'ai du mal à croire que personne n'aie jamais posé de verrou Posix ici.

Reply

Marsh Posté le 25-10-2006 à 15:06:12    

escaflownn a écrit :

Bonjour les cracks.
 
J'ai crée un programme pour me familiariser avec les verrous.
Mon mode opératoire est le suivant, je crée et verrouille un fichier "socket.tmp" dans le repertoire /tmp, puis je mets le programme en pause (getchar).
J'ouvre ce fichier avec l'éditeur vim et je tente d'écrire dessus pour vérifier que le verrou soit bien installé. Or je peux écrire sans problème sur le fichier alors qu'il devrait être vérrouillé.
 
Si j'ouvre le fichier en lecture seulement, le fcntl() ne veut pas le verrouiller en écriture, ce qui me laisse supposer que fcntl() tente bien la pose de verrou.
La fonction is_locked_socket() censée vérifier que le verrou est présent rapporte dans tous les cas que le fichier n'est pas verrouillé !
 
=> J'en conclu que fcntl() démarre la pose du verrou mais cette dernière n'aboutie pas. fcntl() ne renvoit pourtant aucun message d'erreur.
 
main.c

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <socket.h>
  4. #include <unistd.h>
  6. const char test[3]="ab";
  8. int main ( int argc , char** argv )
  9. {
  10. int fd;
  12. chdir ( "/tmp" );
  14. if ( ( fd = open_socket ( "socket.tmp" ) ) < 0 )
  15. {
  16.  printf ( "Cannot create socket file\n" );
  17.  exit ( -1 );
  18. }
  20. printf ( "Press <RETURN> to set lock\n" );
  21. getchar ();
  23. if ( lock_socket ( fd ) < 0 )
  24. {
  25.  printf ( "Cannot lock socket file\n" );
  26.  exit ( -1 );
  27. }
  29. lseek ( fd , 0 , SEEK_END );
  30. write ( fd , &test[0] , 2 );
  32. printf ( "Press <RETURN> to remove lock\n" );
  33. getchar ();
  35. if ( unlock_socket ( fd ) < 0 )
  36.  exit ( -1 );
  38. if ( close_socket ( fd ) < 0 )
  39.  exit ( -1 );
  41. exit ( EXIT_SUCCESS );


 
socket.c

Code :
  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include "socket.h"
  6. #include <stdio.h>
  8. //--------------------------------------------------------------------
  9. /* Function Name      : open_socket
  10. * Object             : Opens an existing socket or creates it !
  11. * Input Parameters   : [char*] path = Name of the socket file.
  12. * Output Parameters  : [int] = File descriptor of the socket file.
  13. *     '-1' if error.
  14. * Functions called   : open(),lseek().
  15. */
  16. //--------------------------------------------------------------------
  17. int open_socket ( char* path )
  18. {
  19. int err, fd;
  21. /* OPEN the file */
  22. fd = open ( path , O_RDWR | O_CREAT,
  23.      S_IRUSR | S_IWUSR );
  24. if ( fd < 0 )
  25.  return SOCKET_ERROR;
  27. /* JUMP at the beginning of the file */
  28. err = lseek ( fd , 0 , SEEK_SET );
  29. if ( err < 0 )
  30.  return SOCKET_ERROR;
  32. return fd;
  33. }
  35. //--------------------------------------------------------------------
  36. /* Function Name      : close_socket
  37. * Object             : Close an existing socket.
  38. * Input Parameters   : [int] fd = File descriptor of the socket file.
  39. * Output Parameters  : [int] = exit status.
  40. *     '-1' if error.
  41. *     '0' if no error.
  42. * Functions called   : close().
  43. */
  44. int close_socket ( int fd )
  45. {
  46. return close ( fd );
  47. }
  49. //--------------------------------------------------------------------
  50. /* Function Name      : unlock_socket
  51. * Object             : Unlock an existing socket.
  52. * Input Parameters   : [int] fd = File descriptor of the socket file.
  53. * Output Parameters  : [int] = exit status.
  54. *     '-1' if error.
  55. *     '0' if no error.
  56. * Functions called   : fcntl().
  57. */
  58. //-------------------------------------------------------------------
  59. int unlock_socket ( int fd )
  60. {
  61. static struct flock lock;
  63. lock.l_type = F_UNLCK;
  64. lock.l_whence = SEEK_SET;
  65. lock.l_start = 0;
  66. lock.l_len = 0;
  68. return fcntl ( fd , F_SETLKW , &lock );
  69. }
  71. //--------------------------------------------------------------------
  72. /* Function Name      : lock_socket
  73. * Object             : Lock an existing socket.
  74. * Input Parameters   : [int] fd = File descriptor of the socket file.
  75. * Output Parameters  : [int] = exit status.
  76. *     '-1' if error.
  77. *     '0' if no error.
  78. * Functions called   : fcntl().
  79. */
  80. //-------------------------------------------------------------------
  81. int lock_socket ( int fd )
  82. {
  83. static struct flock lock;
  85. lock.l_type = F_WRLCK;
  86. lock.l_whence = SEEK_SET;
  87. lock.l_start = 0;
  88. lock.l_len = 0;
  90. return fcntl ( fd , F_SETLKW , &lock );
  91. }
  93. //--------------------------------------------------------------------
  94. /* Function Name      : is_locked_socket
  95. * Object             : Check if an existing socket is locked.
  96. * Input Parameters   : [int] fd = File descriptor of the socket file.
  97. * Output Parameters  : [int] = exit status.
  98. *     the pid of the process if locked.
  99. *     '0' if unlocked.
  100. *     '-1' if error;
  101. * Functions called   : fcntl().
  102. */
  103. //-------------------------------------------------------------------
  104. int is_locked_socket ( int fd )
  105. {
  106. static struct flock lock;
  108. lock.l_type = F_WRLCK;
  109. lock.l_whence = SEEK_SET;
  110. lock.l_start = 0;
  111. lock.l_len = 0;
  113. if ( fcntl ( fd , F_GETLK , &lock ) == -1 )
  114.  return -1;
  116. if ( lock.l_type == F_UNLCK )
  117.  return 0;
  118. else
  119.  return lock.l_pid;
  120. }



 
Désolé, j'ai pas le temps d'examiner ton code en détail. Je remarque quand-même que les fonctions "lock_socket" et "unlock_socket" sont quasiment les mêmes et pourraient être regroupées en une seule qui recevrait un paramètre supplémentaire "lock/unlock". Mais le pb ne vient pas de là.
Télécharge mon cours sur les processus http://fr.lang.free.fr/cours/Processus_Csyst_v1.0.pdf. Il y a un chapitre qui parle de la pose des verrous. Si j'ai un peu de temps, je reviendrai plus tard voir ce qui peut clocher...
 
Petit conseil: tu devrais utiliser de temps en temps "errno" ainsi que "perror()" histoire d'afficher ce que te dit le système quand ça cloche.
Autre remarque: Tes fonctions "lock/unlock" utilisent une structure statique ce qui signifie que la variable "lock" garde ses valeurs entre chaque appel. Si jamais un des membres de "lock" n'est pas réinitialisé alors qu'il le devrait, il gardera la valeur précédente et si celle-ci n'est pas bonne...
En général, une variable locale ne se met "static" que si on a un besoin impératif de garder sa valeur entre chaque appel (cas d'un compteur d'appels par exemple)...


Message édité par Sve@r le 25-10-2006 à 15:20:50

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
Reply

Marsh Posté le 25-10-2006 à 15:46:24    

Merci pour tes précieux conseils, j'ai refondu le code en conséquence.
 
Concernant le problème, l'erreur venait du mode opératoire en deux points:
*tout d'abord vim ne tient pas compte des verrous, pour vérifier que le verrou est posé, il suffit en réalité d'éxécuter deux fois le processus en même temps.
*la fonction is_locked_socket() ne permet pas de vérifier à postériori si le processus a lui même posé un verrou, car un processus peut toujours poser un verrou à la place d'un verrou qu'il a lui même posé antèrieurement. C'est pour cette raison qu'elle renvoyait 0.
 
main.c

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <errno.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7. #include <fcntl.h>
  9. #include "lock.h"
  11. int main ( int argc , char** argv )
  12. {
  13. int fd;
  14. char tab[4] = "ab\n";
  16. if ( chdir ( "/tmp" ) < 0 )
  17. {
  18.  perror ( "[main.c] chdir(0)" );
  19.  exit ( EXIT_FAILURE );
  20. }
  22. fd = open ( "fic_test.tmp" , O_RDWR | O_CREAT , S_IRWXU );
  23. if ( fd < 0 )
  24. {
  25.  perror ( "[main.c] open(0)" );
  26.  exit ( EXIT_FAILURE );
  27. }
  29. if ( lock_file ( fd , LOCK_NOWAIT ) < 0 )
  30. {
  31.  perror ( "[main.c] lock_file(0)" );
  32.  exit ( EXIT_FAILURE );
  33. }
  35. if ( lseek ( fd , 0 , SEEK_END ) < 0 )
  36. {
  37.  perror ( "[main.c] lseek(0)" );
  38.  exit ( EXIT_FAILURE );
  39. }
  41. printf ( "Press <RETURN> to continue\n" );
  42. getchar ( );
  44. if ( write ( fd , &tab[0] , 3 ) < 0 )
  45. {
  46.  perror ( "[main.c] write(0)" );
  47.  exit ( EXIT_FAILURE );
  48. }
  50. if ( lock_file ( fd , LOCK_UNLOCK ) < 0 )
  51. {
  52.  perror ( "[main.c] lock_file(1)" );
  53.  exit ( EXIT_FAILURE );
  54. }
  56. if ( close ( fd ) < 0 )
  57. {
  58.  perror ( "[main.c] close(0)" );
  59.  exit ( EXIT_FAILURE );
  60. }
  62. exit ( EXIT_SUCCESS );
  63. }


 
lock.c

Code :
  1. //--------------------------------------------------------------------
  2. //--------------------------------------------------------------------
  3. /* Lib Name           : file.c
  4. * Ver                : 1.0
  5. * Description        : Provide basic functions to
  6. *    manipulate files.
  7. */
  8. //--------------------------------------------------------------------
  10. #include <fcntl.h>
  11. #include <stdio.h>
  12. #include <errno.h>
  14. #include "lock.h"
  16. //--------------------------------------------------------------------
  17. /* Function Name      : lock_file
  18. * Object             : Lock an opened file.
  19. * Input Parameters   : [int] fd = File descriptor of the file.
  20. *    [int] cmd = kind of lock to apply.
  21. * Output Parameters  : [int] = - '-1' if error.
  22. *     - '0' if no error.
  23. * Functions called   : fcntl().
  24. */
  25. //-------------------------------------------------------------------
  26. int lock_file ( int fd , int cmd )
  27. {
  28. struct flock lock;
  30. /* Setup an exclusive (writing) lock */
  31. lock.l_whence = SEEK_SET;
  32. lock.l_start = 0;
  33. lock.l_len = 0;
  35. /* Apply the lock */
  37. if ( cmd == LOCK_NOWAIT )
  38. {
  39.  lock.l_type = F_WRLCK;
  40.  return fcntl ( fd , F_SETLK , &lock );
  41. }
  42. else if ( cmd == LOCK_WAIT )
  43. {
  44.  lock.l_type = F_WRLCK;
  45.  return fcntl ( fd , F_SETLKW , &lock );
  46. }
  47. else if ( cmd == LOCK_UNLOCK )
  48. {
  49.  lock.l_type = F_UNLCK;
  50.  return fcntl ( fd , F_SETLK , &lock );
  51. }
  52. else
  53. {
  54.  /* Invalid argument */
  55.  errno = EINVAL;
  56.  return -1;
  57. }
  58. }
  60. //--------------------------------------------------------------------
  61. /* Function Name      : lock_is_set
  62. * Object             : Check if an opened file is locked  
  63. *    by AN OTHER processus.
  64. * Input Parameters   : [int] fd = File descriptor of the file.
  65. * Output Parameters  : [int] = - the pid of the process which locked it.
  66. *     - '0' if unlocked.
  67. *     - '-1' if error;
  68. * Functions called   : fcntl().
  69. */
  70. //-------------------------------------------------------------------
  71. int lock_is_set ( int fd )
  72. {
  73. struct flock lock;
  75. /* Test an exclusive (writing) lock */
  76. lock.l_type = F_WRLCK;
  77. lock.l_whence = SEEK_SET;
  78. lock.l_start = 0;
  79. lock.l_len = 0;
  81. /* Apply the lock and check the result */
  82. if ( fcntl ( fd , F_GETLK , &lock ) < 0 )
  83.  return -1;
  85. else if ( lock.l_type == F_UNLCK )
  86.  return 0;
  87. else
  88.  /* lock.l_pid is now the pid of the process
  89.   * owner of the lock */
  90.  return lock.l_pid;
  91. }

Message cité 1 fois
Message édité par escaflownn le 25-10-2006 à 16:57:14
Reply

Marsh Posté le 25-10-2006 à 21:18:00    

escaflownn a écrit :

Merci pour tes précieux conseils.


J'ai pas dit grand chose de réellement utile. Mais si ça marche, tant mieux.


Message édité par Sve@r le 25-10-2006 à 21:18:25

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed