lckpwdf.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152
  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. if (lock_fd != -1)
  45. /* Still locked by own process. */
  46. return -1;
  47. /* Prevent problems caused by multiple threads. */
  48. __UCLIBC_MUTEX_LOCK(mylock);
  49. lock_fd = open (_PATH_PASSWD, O_WRONLY | O_CLOEXEC);
  50. if (lock_fd == -1) {
  51. goto DONE;
  52. }
  53. #ifndef __ASSUME_O_CLOEXEC
  54. /* Make sure file gets correctly closed when process finished. */
  55. fcntl (lock_fd, F_SETFD, FD_CLOEXEC);
  56. #endif
  57. /* Now we have to get exclusive write access. Since multiple
  58. process could try this we won't stop when it first fails.
  59. Instead we set a timeout for the system call. Once the timer
  60. expires it is likely that there are some problems which cannot be
  61. resolved by waiting. (sa_flags have no SA_RESTART. Thus SIGALRM
  62. will EINTR fcntl(F_SETLKW)
  63. It is important that we don't change the signal state. We must
  64. restore the old signal behaviour. */
  65. memset (&new_act, '\0', sizeof (new_act));
  66. new_act.sa_handler = noop_handler;
  67. __sigfillset (&new_act.sa_mask);
  68. /* Install new action handler for alarm and save old.
  69. * This never fails in Linux. */
  70. sigaction (SIGALRM, &new_act, &saved_act);
  71. /* Now make sure the alarm signal is not blocked. */
  72. __sigemptyset (&new_set);
  73. __sigaddset (&new_set, SIGALRM);
  74. sigprocmask (SIG_UNBLOCK, &new_set, &saved_set);
  75. /* Start timer. If we cannot get the lock in the specified time we
  76. get a signal. */
  77. alarm (TIMEOUT);
  78. /* Try to get the lock. */
  79. memset (&fl, '\0', sizeof (fl));
  80. if (F_WRLCK)
  81. fl.l_type = F_WRLCK;
  82. if (SEEK_SET)
  83. fl.l_whence = SEEK_SET;
  84. result = fcntl (lock_fd, F_SETLKW, &fl);
  85. /* Clear alarm. */
  86. alarm (0);
  87. sigprocmask (SIG_SETMASK, &saved_set, NULL);
  88. sigaction (SIGALRM, &saved_act, NULL);
  89. if (result < 0) {
  90. close(lock_fd);
  91. lock_fd = -1;
  92. }
  93. DONE:
  94. __UCLIBC_MUTEX_UNLOCK(mylock);
  95. return 0; /* TODO: return result? */
  96. }
  97. int
  98. ulckpwdf (void)
  99. {
  100. int result;
  101. if (lock_fd == -1)
  102. /* There is no lock set. */
  103. result = -1;
  104. else
  105. {
  106. /* Prevent problems caused by multiple threads. */
  107. __UCLIBC_MUTEX_LOCK(mylock);
  108. result = close (lock_fd);
  109. /* Mark descriptor as unused. */
  110. lock_fd = -1;
  111. /* Clear mutex. */
  112. __UCLIBC_MUTEX_UNLOCK(mylock);
  113. }
  114. return result;
  115. }
  116. static void
  117. noop_handler (int sig)
  118. {
  119. /* We simply return which makes the `fcntl' call return with an error. */
  120. }