ze-filter  (ze-filter-0.8.0-develop-180218)
zeShared.c
Go to the documentation of this file.
1 /*
2  *
3  * ze-filter - Mail Server Filter for sendmail
4  *
5  * Copyright (c) 2001-2018 - Jose-Marcio Martins da Cruz
6  *
7  * Auteur : Jose Marcio Martins da Cruz
8  * jose.marcio.mc@gmail.org
9  *
10  * Historique :
11  * Creation : janvier 2002
12  *
13  * This program is free software, but with restricted license :
14  *
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19  *
20  * More details about ze-filter license can be found at ze-filter
21  * web site : http://foss.jose-marcio.org
22  */
23 
24 #if 0
25 #define _XOPEN_SOURCE 500
26 #endif
27 
28 
29 
30 #include <config.h>
31 
32 #include <ze-sys.h>
33 
34 #include "libze.h"
35 
36 #include "zeShared.h"
37 
38 
39 
40 /* ****************************************************************************
41  * *
42  * *
43  **************************************************************************** */
44 void *
45 SharedFile_Open (shm, name, size)
46  SHMOBJ_T *shm;
47  char *name;
48  size_t size;
49 {
50  int fd;
51  void *buf;
52  struct stat st;
53  size_t osize;
54 
55  if (shm == NULL)
56  return NULL;
57 
58  if (name == NULL)
59  return NULL;
60 
61  if (size == 0)
62  return NULL;
63 
64  if ((fd = open (name, O_RDWR | O_CREAT, 0640)) < 0) {
65  ZE_LogSysError("open error");
66  return NULL;
67  }
68 
69  if (fstat (fd, &st) != 0) {
70  ZE_LogSysError("fstat error");
71  close(fd);
72  return NULL;
73  }
74  osize = st.st_size;
75 
76  if (osize < size) {
77 #if HAVE_FTRUNCATE
78  if (ftruncate(fd, size) != 0) {
79  ZE_LogSysError("ftruncate(%s) error", name);
80  close(fd);
81  return NULL;
82  }
83 #else
84  if ((buf = malloc (size)) == NULL) {
85  ZE_LogSysError("malloc error");
86  close(fd);
87  return NULL;
88  }
89  memset (buf, 0, size);
90 #if HAVE_PWRITE
91  if (pwrite (fd, buf, (size - osize), osize) < (size - osize)) {
92  ZE_LogSysError("pwrite error");
93  }
94 #else
95  if (write (fd, buf, size) < 0) {
96  ZE_LogSysError("write error");
97  }
98 #endif
99  free (buf);
100 #endif
101  }
102 
103  if ((buf = mmap (NULL, size, (PROT_READ | PROT_WRITE),
104  MAP_SHARED, fd, 0)) == NULL) {
105  ZE_LogSysError("mmap error");
106  close (fd);
107  return NULL;
108  }
109 
110 #if 0
111  close (fd);
112  fd = -1;
113 #endif
114 
115  if ((shm->name = strdup (name)) == NULL) {
116  ZE_LogSysError("strdup error");
117  }
118  shm->buf = buf;
119  shm->size = size;
120  shm->fd = fd;
121 
122  return buf;
123 }
124 
125 /* ****************************************************************************
126  * *
127  * *
128  **************************************************************************** */
129 void
131  SHMOBJ_T *shm;
132 {
133  if (shm == NULL)
134  return;
135 
136  if (munmap (shm->buf, shm->size) != 0) {
137  ZE_LogSysError("munmap error");
138  }
139 
140  if (shm->fd >= 0)
141  close (shm->fd);
142 
143  if (shm->name != NULL)
144  free (shm->name);
145 
146  memset (shm, 0, sizeof (SHMOBJ_T));
147 }
148 
149 /* ****************************************************************************
150  * *
151  * *
152  **************************************************************************** */
153 size_t
155  SHMOBJ_T *shm;
156 {
157  struct stat st;
158 
159  if (shm == NULL)
160  return -1;
161 
162  if (fstat (shm->fd, &st) != 0) {
163  ZE_LogSysError("fstat error");
164  return -1;
165  }
166  return st.st_size;
167 }
168 
169 /* ****************************************************************************
170  * *
171  * *
172  **************************************************************************** */
173 size_t
174 SharedFile_Resize (shm, size)
175  SHMOBJ_T *shm;
176  size_t size;
177 {
178  struct stat st;
179 
180  if (shm == NULL)
181  return -1;
182 
183  if (fstat (shm->fd, &st) != 0) {
184  ZE_LogSysError("fstat error");
185  return -1;
186  }
187  if (st.st_size != size) {
188  if (ftruncate (shm->fd, size) != 0) {
189  ZE_LogSysError("ftruncate error");
190  return -1;
191  }
192  }
193  return size;
194 }
195 
196 
197 /* ****************************************************************************
198  * *
199  * *
200  **************************************************************************** */
201 void *
202 SharedMemory_Open (shm, name, size)
203  SHMOBJ_T *shm;
204  char *name;
205  size_t size;
206 {
207  int fd;
208  struct stat st;
209  size_t osize;
210  void *buf;
211 
212  if (shm == NULL)
213  return NULL;
214 
215  if (name == NULL)
216  return NULL;
217 
218  if (size == 0)
219  return NULL;
220 
221  if ((fd = shm_open (name, O_RDWR | O_CREAT, 0640)) < 0) {
222  ZE_LogSysError("shm_open error");
223  return NULL;
224  }
225 
226  if (fstat (fd, &st) != 0) {
227  ZE_LogSysError("fstat error");
228  close(fd);
229  return NULL;
230  }
231  osize = st.st_size;
232 
233  if (osize < size) {
234 #if HAVE_FTRUNCATE
235  if (ftruncate(fd, size) != 0) {
236  ZE_LogSysError("ftruncate(%s) error", name);
237  close(fd);
238  return NULL;
239  }
240 #else
241  if ((buf = malloc (size)) == NULL) {
242  ZE_LogSysError("malloc error");
243  close(fd);
244  return NULL;
245  }
246  memset (buf, 0, size);
247 #if HAVE_PWRITE
248  if (pwrite (fd, buf, (size - osize), osize) < (size - osize)) {
249  ZE_LogSysError("pwrite error");
250  }
251 #else
252  if (write (fd, buf, size) < 0) {
253  ZE_LogSysError("write error");
254  }
255 #endif
256  free (buf);
257 #endif
258  }
259 
260  if ((buf = mmap (NULL, size, (PROT_READ | PROT_WRITE),
261  MAP_SHARED, fd, 0)) == NULL) {
262  ZE_LogSysError("mmap error");
263  return NULL;
264  }
265 
266 #if 0
267  close(fd);
268  fd = -1;
269 #endif
270 
271  shm->fd = fd;
272  if ((shm->name = strdup (name)) == NULL) {
273  ZE_LogSysError("strdup error");
274  }
275  shm->buf = buf;
276  shm->size = size;
277 
278  return buf;
279 }
280 
281 /* ****************************************************************************
282  * *
283  * *
284  **************************************************************************** */
285 void
287  SHMOBJ_T *shm;
288 {
289  if (shm == NULL)
290  return;
291 
292  if (shm_unlink (shm->name) != 0) {
293  ZE_LogSysError("shm_unlink error");
294  }
295 
296  if (munmap (shm->buf, shm->size) != 0) {
297  ZE_LogSysError("munmap error");
298  }
299 
300  if (shm->fd >= 0)
301  close(shm->fd);
302  if (shm->name != NULL)
303  free (shm->name);
304 
305  memset (shm, 0, sizeof (SHMOBJ_T));
306 }
307 
308 /* ****************************************************************************
309  * *
310  * *
311  **************************************************************************** */
312 size_t
314  SHMOBJ_T *shm;
315 {
316  struct stat st;
317 
318  if (shm == NULL)
319  return -1;
320 
321  if (fstat (shm->fd, &st) != 0) {
322  ZE_LogSysError("fstat error");
323  return -1;
324  }
325  return st.st_size;
326 }
327 
328 /* ****************************************************************************
329  * *
330  * *
331  **************************************************************************** */
332 size_t
334  SHMOBJ_T *shm;
335  size_t size;
336 {
337  struct stat st;
338 
339  if (shm == NULL)
340  return -1;
341 
342  if (fstat (shm->fd, &st) != 0) {
343  ZE_LogSysError("fstat error");
344  return -1;
345  }
346  if (st.st_size != size) {
347  if (ftruncate (shm->fd, size) != 0) {
348  ZE_LogSysError("ftruncate error");
349  return -1;
350  }
351  }
352  return size;
353 }
size_t size
Definition: zeShared.h:36
void SharedFile_Close(SHMOBJ_T *shm)
Definition: zeShared.c:130
void * buf
Definition: zeShared.h:35
void * SharedFile_Open(SHMOBJ_T *shm, char *name, size_t size)
Definition: zeShared.c:45
void * SharedMemory_Open(SHMOBJ_T *shm, char *name, size_t size)
Definition: zeShared.c:202
int fd
Definition: zeShared.h:34
char * name
Definition: zeShared.h:37
void SharedMemory_Close(SHMOBJ_T *shm)
Definition: zeShared.c:286
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
size_t SharedMemory_Resize(SHMOBJ_T *shm, size_t size)
Definition: zeShared.c:333
size_t SharedMemory_Size(SHMOBJ_T *shm)
Definition: zeShared.c:313
size_t SharedFile_Size(SHMOBJ_T *shm)
Definition: zeShared.c:154
size_t SharedFile_Resize(SHMOBJ_T *shm, size_t size)
Definition: zeShared.c:174