sms_lock.c
上传用户:mei_mei897
上传日期:2007-01-05
资源大小:82k
文件大小:6k
源码类别:

手机短信编程

开发平台:

Unix_Linux

  1. /* -------------------------------------------------------------------- */
  2. /* SMS Client, send messages to mobile phones and pagers */
  3. /* */
  4. /* sms_lock.c */
  5. /* */
  6. /*  Copyright (C) 1997,1998 Angelo Masci */
  7. /* */
  8. /*  This library is free software; you can redistribute it and/or */
  9. /*  modify it under the terms of the GNU Library General Public */
  10. /*  License as published by the Free Software Foundation; either */
  11. /*  version 2 of the License, or (at your option) any later version. */
  12. /* */
  13. /*  This library is distributed in the hope that it will be useful, */
  14. /*  but WITHOUT ANY WARRANTY; without even the implied warranty of */
  15. /*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
  16. /*  Library General Public License for more details. */
  17. /* */
  18. /*  You should have received a copy of the GNU Library General Public */
  19. /*  License along with this library; if not, write to the Free */
  20. /*  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  21. /* */
  22. /*  You can contact the author at this e-mail address: */
  23. /* */
  24. /*  angelo@styx.demon.co.uk */
  25. /* */
  26. /* -------------------------------------------------------------------- */
  27. /* $Id$
  28.    -------------------------------------------------------------------- */
  29. #include <string.h>
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  32. #include <fcntl.h>
  33. #include <unistd.h>
  34. #include <errno.h>
  35. #include <stdio.h>
  36. #include <signal.h>
  37. #include "logfile.h"
  38. #include "sms_lock.h"
  39. #include "common.h"
  40. /* -------------------------------------------------------------------- */
  41. /* -------------------------------------------------------------------- */
  42. static pid_t resource_lock_pid(char *resource_lockfile)
  43. {
  44. int  lock_fd,
  45. i,
  46. eof;
  47. pid_t pid;
  48. char buf[512],
  49. c;
  50. lock_fd = open(resource_lockfile, O_RDONLY);
  51. if (lock_fd == -1)
  52. { return(-1);
  53. }
  54. eof = FALSE;
  55. i = 0;
  56. while((i < 11) && (eof == FALSE))
  57. {
  58. switch (read(lock_fd, &c, 1))
  59. {
  60. case 1:
  61. buf[i] = c;
  62. i++;
  63. break;
  64. case -1:
  65. if (errno != EINTR)
  66. { lprintf(LOG_ERROR, "Reading pid from lockfile '%s'n", resource_lockfile);
  67. exit(-1);
  68. }
  69. break;
  70. case 0:
  71. eof = TRUE;
  72. }
  73. }
  74. buf[i] = '';
  75. if (sscanf(buf, "%10dn", &pid) == 1)
  76. { return pid;
  77. }
  78. return -1;
  79. }
  80. /* -------------------------------------------------------------------- */
  81. /* -------------------------------------------------------------------- */
  82. int resource_unlock(char *resource_lockfile)
  83. {
  84. pid_t pid;
  85. pid = resource_lock_pid(resource_lockfile);
  86. if (pid == getpid())
  87. {
  88. lprintf(LOG_VERBOSE, "Removing Lockfile '%s'n", resource_lockfile);
  89. unlink(resource_lockfile);
  90. }
  91. return 0;
  92. }
  93. /* -------------------------------------------------------------------- */
  94. /* -------------------------------------------------------------------- */
  95. int resource_locked(char *resource_lockfile)
  96. {
  97. pid_t pid;
  98. if (access(resource_lockfile, F_OK) == 0)
  99. {
  100. /* lockfile exists */
  101. pid = resource_lock_pid(resource_lockfile);
  102. if (pid != -1)
  103. {
  104. /* Is there a process with this pid? */
  105. if (kill(pid, 0) == 0)
  106. { return -1; /* Process exists */
  107. }
  108. else
  109. { if (errno == EPERM)
  110. { return -1; /* Process exists */
  111. }
  112. }
  113. /* Process does not exist */
  114. /* we can unlink this lockfile as */
  115. /* it is stale. */
  116. lprintf(LOG_VERBOSE, "Removing Stale Lockfile '%s'n", resource_lockfile);
  117. unlink(resource_lockfile);
  118. return 0;
  119. }
  120. else
  121. { /* Could not determine PID of */
  122. /* owner of this lockfile! */
  123. return -1;
  124. }
  125. }
  126. /* No process holds the lock */
  127. return 0;
  128. }
  129. /* -------------------------------------------------------------------- */
  130. /* -------------------------------------------------------------------- */
  131. int resource_lock(char *resource_lockfile)
  132. {
  133. int  lock_fd,
  134. i,
  135. len;
  136. char buf[512];
  137. if (resource_locked(resource_lockfile) == 0)
  138. {
  139. lock_fd = open(resource_lockfile, O_CREAT|O_WRONLY|O_EXCL, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
  140. if (lock_fd == -1)
  141. { if (errno == EEXIST)
  142. { /* Could not create lockfile  */
  143. /* A lockfile already exists */
  144. /* The most likely reason for */
  145. /* this is another process */
  146. /* generating one after our */
  147. /* call to resource_locked() */
  148. return -1;
  149. }
  150. lprintf(LOG_ERROR, "Cannot create lockfile %sn", resource_lockfile);
  151. exit(-1);
  152. }
  153. len = sprintf(buf, "%10d sms_clientn", (int)getpid());
  154. i = 0;
  155. while(i < len)
  156. {
  157. switch (write(lock_fd, &buf[i], 1))
  158. {
  159. case 1:
  160. i++;
  161. break;
  162. case -1:
  163. if (errno != EINTR)
  164. { lprintf(LOG_ERROR, "Reading pid from lockfile '%s'n", resource_lockfile);
  165. exit(-1);
  166. }
  167. }
  168. }
  169. chmod(resource_lockfile, S_IRUSR|S_IRGRP|S_IROTH);
  170. close(lock_fd);
  171. /* Created lockfile with this pid */
  172. lprintf(LOG_VERBOSE, "Created Lockfile '%s'n", resource_lockfile);
  173. return 0;
  174. }
  175. /* Could not create lockfile */
  176. return -1;
  177. }
  178. /* -------------------------------------------------------------------- */
  179. /* -------------------------------------------------------------------- */
  180. int resource_wait(char *resource_lockfile, long delay)
  181. {
  182. sms_usleep(delay); /* Sleep between checks on the */
  183. /* lockfile. */
  184. /* What would be really nice would */
  185. /* be a way to block and return if */
  186. /* the attributes on the lockfile */
  187. /* change. */
  188. return 0;
  189. }
  190. /* -------------------------------------------------------------------- */
  191. /* -------------------------------------------------------------------- */
  192. void resource_check_lockdir(char *resource_lockfile)
  193. {
  194. char  lock_dir[512], 
  195. *dst, 
  196. *ptr;
  197. ptr = lock_dir;
  198. dst = lock_dir;
  199. while (*resource_lockfile != '')
  200. {
  201. if (*resource_lockfile == '/')
  202. { ptr = dst;
  203. }
  204. *dst++ = *resource_lockfile++;
  205. }
  206. if (ptr == lock_dir)
  207. { *ptr++ = '.';
  208. }
  209. *ptr = '';
  210. if (access(lock_dir, R_OK|W_OK|X_OK) < 0)
  211. { lprintf(LOG_ERROR, "Cannot access lock directory '%s'n", lock_dir);
  212. exit(-1); 
  213. }
  214. }