Update to db 2.3.10.
[kopensolaris-gnu/glibc.git] / db2 / log / log_archive.c
1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 1997
5  *      Sleepycat Software.  All rights reserved.
6  */
7
8 #include "config.h"
9
10 #ifndef lint
11 static const char sccsid[] = "@(#)log_archive.c 10.26 (Sleepycat) 9/23/97";
12 #endif /* not lint */
13
14 #ifndef NO_SYSTEM_INCLUDES
15 #include <sys/types.h>
16
17 #include <errno.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 #endif
22
23 #include "db_int.h"
24 #include "db_dispatch.h"
25 #include "shqueue.h"
26 #include "log.h"
27 #include "clib_ext.h"
28 #include "common_ext.h"
29
30 static int __absname __P((char *, char *, char **));
31 static int __build_data __P((DB_LOG *, char *, char ***, void *(*)(size_t)));
32 static int __cmpfunc __P((const void *, const void *));
33 static int __usermem __P((char ***, void *(*)(size_t)));
34
35 /*
36  * log_archive --
37  *      Supporting function for db_archive(1).
38  */
39 int
40 log_archive(dblp, listp, flags, db_malloc)
41         DB_LOG *dblp;
42         char ***listp;
43         int flags;
44         void *(*db_malloc) __P((size_t));
45 {
46         DBT rec;
47         DB_LSN stable_lsn;
48         u_int32_t fnum;
49         int array_size, n, ret;
50         char **array, **arrayp, *name, *p, *pref, buf[MAXPATHLEN];
51
52         fnum = 0;                               /* XXX: Shut the compiler up. */
53
54 #define OKFLAGS (DB_ARCH_ABS | DB_ARCH_DATA | DB_ARCH_LOG)
55         if (flags != 0) {
56                 if ((ret =
57                     __db_fchk(dblp->dbenv, "log_archive", flags, OKFLAGS)) != 0)
58                         return (ret);
59                 if ((ret =
60                     __db_fcchk(dblp->dbenv,
61                         "log_archive", flags, DB_ARCH_DATA, DB_ARCH_LOG)) != 0)
62                         return (ret);
63         }
64
65         /*
66          * Get the absolute pathname of the current directory.  It would
67          * be nice to get the shortest pathname of the database directory,
68          * but that's just not possible.
69          */
70         if (LF_ISSET(DB_ARCH_ABS)) {
71                 __set_errno (0);
72                 if ((pref = getcwd(buf, sizeof(buf))) == NULL)
73                         return (errno == 0 ? ENOMEM : errno);
74         } else
75                 pref = NULL;
76
77         switch (LF_ISSET(~DB_ARCH_ABS)) {
78         case DB_ARCH_DATA:
79                 return (__build_data(dblp, pref, listp, db_malloc));
80         case DB_ARCH_LOG:
81                 memset(&rec, 0, sizeof(rec));
82                 if (F_ISSET(dblp, DB_AM_THREAD))
83                         F_SET(&rec, DB_DBT_MALLOC);
84                 if ((ret = log_get(dblp, &stable_lsn, &rec, DB_LAST)) != 0)
85                         return (ret);
86                 if (F_ISSET(dblp, DB_AM_THREAD))
87                         free(rec.data);
88                 fnum = stable_lsn.file;
89                 break;
90         case 0:
91                 if ((ret = __log_findckp(dblp, &stable_lsn)) != 0) {
92                         if (ret != DB_NOTFOUND)
93                                 return (ret);
94                         *listp = NULL;
95                         return (0);
96                 }
97                 /* Remove any log files before the last stable LSN. */
98                 fnum = stable_lsn.file - 1;
99                 break;
100         }
101
102 #define LIST_INCREMENT  64
103         /* Get some initial space. */
104         if ((array =
105             (char **)malloc(sizeof(char *) * (array_size = 10))) == NULL)
106                 return (ENOMEM);
107         array[0] = NULL;
108
109         /* Build an array of the file names. */
110         for (n = 0; fnum > 0; --fnum) {
111                 if ((ret = __log_name(dblp, fnum, &name)) != 0)
112                         goto err;
113                 if (__db_exists(name, NULL) != 0)
114                         break;
115
116                 if (n >= array_size - 1) {
117                         array_size += LIST_INCREMENT;
118                         if ((array = (char **)realloc(array,
119                             sizeof(char *) * array_size)) == NULL) {
120                                 ret = ENOMEM;
121                                 goto err;
122                         }
123                 }
124
125                 if (LF_ISSET(DB_ARCH_ABS)) {
126                         if ((ret = __absname(pref, name, &array[n])) != 0)
127                                 goto err;
128                         FREES(name);
129                 } else if ((p = __db_rpath(name)) != NULL) {
130                         if ((array[n] = (char *)strdup(p + 1)) == NULL) {
131                                 ret = ENOMEM;
132                                 goto err;
133                         }
134                         FREES(name);
135                 } else
136                         array[n] = name;
137
138                 array[++n] = NULL;
139         }
140
141         /* If there's nothing to return, we're done. */
142         if (n == 0) {
143                 *listp = NULL;
144                 ret = 0;
145                 goto err;
146         }
147
148         /* Sort the list. */
149         qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
150
151         /* Rework the memory. */
152         if ((ret = __usermem(&array, db_malloc)) != 0)
153                 goto err;
154
155         *listp = array;
156         return (0);
157
158 err:    if (array != NULL) {
159                 for (arrayp = array; *arrayp != NULL; ++arrayp)
160                         FREES(*arrayp);
161                 free(array);
162         }
163         return (ret);
164 }
165
166 /*
167  * __build_data --
168  *      Build a list of datafiles for return.
169  */
170 static int
171 __build_data(dblp, pref, listp, db_malloc)
172         DB_LOG *dblp;
173         char *pref, ***listp;
174         void *(*db_malloc) __P((size_t));
175 {
176         DBT rec;
177         DB_LSN lsn;
178         __log_register_args *argp;
179         u_int32_t rectype;
180         int array_size, last, n, nxt, ret;
181         char **array, **arrayp, *p, *real_name;
182
183         /* Get some initial space. */
184         if ((array =
185             (char **)malloc(sizeof(char *) * (array_size = 10))) == NULL)
186                 return (ENOMEM);
187         array[0] = NULL;
188
189         memset(&rec, 0, sizeof(rec));
190         if (F_ISSET(dblp, DB_AM_THREAD))
191                 F_SET(&rec, DB_DBT_MALLOC);
192         for (n = 0, ret = log_get(dblp, &lsn, &rec, DB_FIRST);
193             ret == 0; ret = log_get(dblp, &lsn, &rec, DB_NEXT)) {
194                 if (rec.size < sizeof(rectype)) {
195                         ret = EINVAL;
196                         __db_err(dblp->dbenv, "log_archive: bad log record");
197                         goto lg_free;
198                 }
199
200                 memcpy(&rectype, rec.data, sizeof(rectype));
201                 if (rectype != DB_log_register) {
202                         if (F_ISSET(dblp, DB_AM_THREAD)) {
203                                 free(rec.data);
204                                 rec.data = NULL;
205                         }
206                         continue;
207                 }
208                 if ((ret = __log_register_read(rec.data, &argp)) != 0) {
209                         ret = EINVAL;
210                         __db_err(dblp->dbenv,
211                             "log_archive: unable to read log record");
212                         goto lg_free;
213                 }
214
215                 if (n >= array_size - 1) {
216                         array_size += LIST_INCREMENT;
217                         if ((array = (char **)realloc(array,
218                             sizeof(char *) * array_size)) == NULL) {
219                                 ret = ENOMEM;
220                                 goto lg_free;
221                         }
222                 }
223
224                 if ((array[n] = (char *)strdup(argp->name.data)) == NULL) {
225                         ret = ENOMEM;
226 lg_free:                if (F_ISSET(&rec, DB_DBT_MALLOC) && rec.data != NULL)
227                                 free(rec.data);
228                         goto err1;
229                 }
230
231                 array[++n] = NULL;
232                 free(argp);
233
234                 if (F_ISSET(dblp, DB_AM_THREAD)) {
235                         free(rec.data);
236                         rec.data = NULL;
237                 }
238         }
239
240         /* If there's nothing to return, we're done. */
241         if (n == 0) {
242                 ret = 0;
243                 *listp = NULL;
244                 goto err1;
245         }
246
247         /* Sort the list. */
248         qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
249
250         /*
251          * Build the real pathnames, discarding nonexistent files and
252          * duplicates.
253          */
254         for (last = nxt = 0; nxt < n;) {
255                 /*
256                  * Discard duplicates.  Last is the next slot we're going
257                  * to return to the user, nxt is the next slot that we're
258                  * going to consider.
259                  */
260                 if (last != nxt) {
261                         array[last] = array[nxt];
262                         array[nxt] = NULL;
263                 }
264                 for (++nxt; nxt < n &&
265                     strcmp(array[last], array[nxt]) == 0; ++nxt) {
266                         FREES(array[nxt]);
267                         array[nxt] = NULL;
268                 }
269
270                 /* Get the real name. */
271                 if ((ret = __db_appname(dblp->dbenv,
272                     DB_APP_DATA, NULL, array[last], NULL, &real_name)) != 0)
273                         goto err2;
274
275                 /* If the file doesn't exist, ignore it. */
276                 if (__db_exists(real_name, NULL) != 0) {
277                         FREES(real_name);
278                         FREES(array[last]);
279                         array[last] = NULL;
280                         continue;
281                 }
282
283                 /* Rework the name as requested by the user. */
284                 FREES(array[last]);
285                 array[last] = NULL;
286                 if (pref != NULL) {
287                         ret = __absname(pref, real_name, &array[last]);
288                         FREES(real_name);
289                         if (ret != 0)
290                                 goto err2;
291                 } else if ((p = __db_rpath(real_name)) != NULL) {
292                         array[last] = (char *)strdup(p + 1);
293                         FREES(real_name);
294                         if (array[last] == NULL)
295                                 goto err2;
296                 } else
297                         array[last] = real_name;
298                 ++last;
299         }
300
301         /* NULL-terminate the list. */
302         array[last] = NULL;
303
304         /* Rework the memory. */
305         if ((ret = __usermem(&array, db_malloc)) != 0)
306                 goto err1;
307
308         *listp = array;
309         return (0);
310
311 err2:   /*
312          * XXX
313          * We've possibly inserted NULLs into the array list, so clean up a
314          * bit so that the other error processing works.
315          */
316         if (array != NULL)
317                 for (; nxt < n; ++nxt)
318                         FREES(array[nxt]);
319         /* FALLTHROUGH */
320
321 err1:   if (array != NULL) {
322                 for (arrayp = array; *arrayp != NULL; ++arrayp)
323                         FREES(*arrayp);
324                 free(array);
325         }
326         return (ret);
327 }
328
329 /*
330  * __absname --
331  *      Return an absolute path name for the file.
332  */
333 static int
334 __absname(pref, name, newnamep)
335         char *pref, *name, **newnamep;
336 {
337         size_t l_pref, l_name;
338         char *newname;
339
340         l_pref = strlen(pref);
341         l_name = strlen(name);
342
343         /* Malloc space for concatenating the two. */
344         if ((newname = (char *)malloc(l_pref + l_name + 2)) == NULL)
345                 return (ENOMEM);
346
347         /* Build the name. */
348         memcpy(newname, pref, l_pref);
349         if (strchr(PATH_SEPARATOR, newname[l_pref - 1]) == NULL)
350                 newname[l_pref++] = PATH_SEPARATOR[0];
351         memcpy(newname + l_pref, name, l_name + 1);
352         *newnamep = newname;
353
354         return (0);
355 }
356
357 /*
358  * __usermem --
359  *      Create a single chunk of memory that holds the returned information.
360  *      If the user has their own malloc routine, use it.
361  */
362 static int
363 __usermem(listp, func)
364         char ***listp;
365         void *(*func) __P((size_t));
366 {
367         size_t len;
368         char **array, **arrayp, **orig, *strp;
369
370         /* Find out how much space we need. */
371         for (len = 0, orig = *listp; *orig != NULL; ++orig)
372                 len += sizeof(char *) + strlen(*orig) + 1;
373         len += sizeof(char *);
374
375         /*
376          * Allocate it and set up the pointers.
377          *
378          * XXX
379          * Don't simplify this expression, SunOS compilers don't like it.
380          */
381         if (func == NULL)
382                 array = (char **)malloc(len);
383         else
384                 array = (char **)func(len);
385         if (array == NULL)
386                 return (ENOMEM);
387         strp = (char *)(array + (orig - *listp) + 1);
388
389         /* Copy the original information into the new memory. */
390         for (orig = *listp, arrayp = array; *orig != NULL; ++orig, ++arrayp) {
391                 len = strlen(*orig);
392                 memcpy(strp, *orig, len + 1);
393                 *arrayp = strp;
394                 strp += len + 1;
395
396                 FREES(*orig);
397         }
398
399         /* NULL-terminate the list. */
400         *arrayp = NULL;
401
402         free(*listp);
403         *listp = array;
404
405         return (0);
406 }
407
408 static int
409 __cmpfunc(p1, p2)
410         const void *p1, *p2;
411 {
412         return (strcmp(*((char **)p1), *((char **)p2)));
413 }