lckpwdf.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
  1. /* vi: set sw=4 ts=4: */
  2. /* Handle locking of password file.
  3. Copyright (C) 1996,98,2000,02 Free Software Foundation, Inc.
  4. This file is part of the GNU C Library.
  5. Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
  6. The GNU C Library is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU Lesser General Public
  8. License as published by the Free Software Foundation; either
  9. version 2.1 of the License, or (at your option) any later version.
  10. The GNU C Library is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. Lesser General Public License for more details.
  14. You should have received a copy of the GNU Lesser General Public
  15. License along with the GNU C Library; if not, write to the Free
  16. Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17. 02111-1307 USA. */
  18. #include <features.h>
  19. #include <fcntl.h>
  20. #include <signal.h>
  21. #include <string.h>
  22. #include <unistd.h>
  23. #include <sys/file.h>
  24. #include <paths.h>
  25. #include <shadow.h>
  26. /* How long to wait for getting the lock before returning with an error. */
  27. #define TIMEOUT 15 /* sec */
  28. /* File descriptor for lock file. */
  29. static int lock_fd = -1;
  30. /* Prevent problems in multithreaded program by using mutex. */
  31. #include <bits/uClibc_mutex.h>
  32. __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
  33. /* Prototypes for local functions. */
  34. static void noop_handler (int __sig);
  35. int
  36. lckpwdf (void)
  37. {
  38. sigset_t saved_set; /* Saved set of caught signals. */
  39. struct sigaction saved_act; /* Saved signal action. */
  40. sigset_t new_set; /* New set of caught signals. */
  41. struct sigaction new_act; /* New signal action. */
  42. struct flock fl; /* Information struct for locking. */
  43. int result;
  44. int rv = -1;
  45. if (lock_fd != -1)
  46. /* Still locked by own process. */
  47. return -1;
  48. /* Prevent problems caused by multiple threads. */
  49. __UCLIBC_MUTEX_LOCK(mylock);
  50. lock_fd = open (_PATH_PASSWD, O_WRONLY | O_CLOEXEC);
  51. if (lock_fd == -1) {
  52. goto DONE;
  53. }
  54. #ifndef __ASSUME_O_CLOEXEC
  55. /* Make sure file gets correctly closed when process finished. */
  56. fcntl (lock_fd, F_SETFD, FD_CLOEXEC);
  57. #endif
  58. /* Now we have to get exclusive write access. Since multiple
  59. process could try this we won't stop when it first fails.
  60. Instead we set a timeout for the system call. Once the timer
  61. expires it is likely that there are some problems which cannot be
  62. resolved by waiting. (sa_flags have no SA_RESTART. Thus SIGALRM
  63. will EINTR fcntl(F_SETLKW)
  64. It is important that we don't change the signal state. We must
  65. restore the old signal behaviour. */
  66. memset (&new_act, '\0', sizeof (new_act));
  67. new_act.sa_handler = noop_handler;
  68. __sigfillset (&new_act.sa_mask);
  69. /* Install new action handler for alarm and save old.
  70. * This never fails in Linux. */
  71. sigaction (SIGALRM, &new_act, &saved_act);
  72. /* Now make sure the alarm signal is not blocked. */
  73. __sigemptyset (&new_set);
  74. __sigaddset (&new_set, SIGALRM);
  75. sigprocmask (SIG_UNBLOCK, &new_set, &saved_set);
  76. /* Start timer. If we cannot get the lock in the specified time we
  77. get a signal. */
  78. alarm (TIMEOUT);
  79. /* Try to get the lock. */
  80. memset (&fl, '\0', sizeof (fl));
  81. if (F_WRLCK)
  82. fl.l_type = F_WRLCK;
  83. if (SEEK_SET)
  84. fl.l_whence = SEEK_SET;
  85. result = fcntl (lock_fd, F_SETLKW, &fl);
  86. /* Clear alarm. */
  87. alarm (0);
  88. sigprocmask (SIG_SETMASK, &saved_set, NULL);
  89. sigaction (SIGALRM, &saved_act, NULL);
  90. if (result < 0) {
  91. close(lock_fd);
  92. lock_fd = -1;
  93. goto DONE;
  94. }
  95. rv = 0;
  96. DONE:
  97. __UCLIBC_MUTEX_UNLOCK(mylock);
  98. return rv;
  99. }
  100. int
  101. ulckpwdf (void)
  102. {
  103. int result;
  104. if (lock_fd == -1)
  105. /* There is no lock set. */
  106. result = -1;
  107. else
  108. {
  109. /* Prevent problems caused by multiple threads. */
  110. __UCLIBC_MUTEX_LOCK(mylock);
  111. result = close (lock_fd);
  112. /* Mark descriptor as unused. */
  113. lock_fd = -1;
  114. /* Clear mutex. */
  115. __UCLIBC_MUTEX_UNLOCK(mylock);
  116. }
  117. return result;
  118. }
  119. static void
  120. noop_handler (int sig attribute_unused) {
  121. /* We simply return which makes the `fcntl' call return with an error. */
  122. }