1/* rev_file.c --- revision file and index access functions
2 *
3 * ====================================================================
4 *    Licensed to the Apache Software Foundation (ASF) under one
5 *    or more contributor license agreements.  See the NOTICE file
6 *    distributed with this work for additional information
7 *    regarding copyright ownership.  The ASF licenses this file
8 *    to you under the Apache License, Version 2.0 (the
9 *    "License"); you may not use this file except in compliance
10 *    with the License.  You may obtain a copy of the License at
11 *
12 *      http://www.apache.org/licenses/LICENSE-2.0
13 *
14 *    Unless required by applicable law or agreed to in writing,
15 *    software distributed under the License is distributed on an
16 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 *    KIND, either express or implied.  See the License for the
18 *    specific language governing permissions and limitations
19 *    under the License.
20 * ====================================================================
21 */
22
23#include "rev_file.h"
24#include "fs_fs.h"
25#include "index.h"
26#include "low_level.h"
27#include "util.h"
28
29#include "../libsvn_fs/fs-loader.h"
30
31#include "private/svn_io_private.h"
32#include "svn_private_config.h"
33
34/* Initialize the *FILE structure for REVISION in filesystem FS.  Set its
35 * pool member to the provided POOL. */
36static void
37init_revision_file(svn_fs_fs__revision_file_t *file,
38                   svn_fs_t *fs,
39                   svn_revnum_t revision,
40                   apr_pool_t *pool)
41{
42  fs_fs_data_t *ffd = fs->fsap_data;
43
44  file->is_packed = svn_fs_fs__is_packed_rev(fs, revision);
45  file->start_revision = svn_fs_fs__packed_base_rev(fs, revision);
46
47  file->file = NULL;
48  file->stream = NULL;
49  file->p2l_stream = NULL;
50  file->l2p_stream = NULL;
51  file->block_size = ffd->block_size;
52  file->l2p_offset = -1;
53  file->l2p_checksum = NULL;
54  file->p2l_offset = -1;
55  file->p2l_checksum = NULL;
56  file->footer_offset = -1;
57  file->pool = pool;
58}
59
60/* Baton type for set_read_only() */
61typedef struct set_read_only_baton_t
62{
63  /* File to set to read-only. */
64  const char *file_path;
65
66  /* Scratch pool sufficient life time.
67   * Ideally the pool that we registered the cleanup on. */
68  apr_pool_t *pool;
69} set_read_only_baton_t;
70
71/* APR pool cleanup callback taking a set_read_only_baton_t baton and then
72 * (trying to) set the specified file to r/o mode. */
73static apr_status_t
74set_read_only(void *baton)
75{
76  set_read_only_baton_t *ro_baton = baton;
77  apr_status_t status = APR_SUCCESS;
78  svn_error_t *err;
79
80  err = svn_io_set_file_read_only(ro_baton->file_path, TRUE, ro_baton->pool);
81  if (err)
82    {
83      status = err->apr_err;
84      svn_error_clear(err);
85    }
86
87  return status;
88}
89
90/* If the file at PATH is read-only, attempt to make it writable.  The
91 * original state will be restored with RESULT_POOL gets cleaned up.
92 * SCRATCH_POOL is for temporary allocations. */
93static svn_error_t *
94auto_make_writable(const char *path,
95                   apr_pool_t *result_pool,
96                   apr_pool_t *scratch_pool)
97{
98  svn_boolean_t is_read_only;
99  apr_finfo_t finfo;
100
101  SVN_ERR(svn_io_stat(&finfo, path, SVN__APR_FINFO_READONLY, scratch_pool));
102  SVN_ERR(svn_io__is_finfo_read_only(&is_read_only, &finfo, scratch_pool));
103
104  if (is_read_only)
105    {
106      /* Tell the pool to restore the r/o state upon cleanup
107         (assuming the file will still exist, failing silently otherwise). */
108      set_read_only_baton_t *baton = apr_pcalloc(result_pool,
109                                                  sizeof(*baton));
110      baton->pool = result_pool;
111      baton->file_path = apr_pstrdup(result_pool, path);
112      apr_pool_cleanup_register(result_pool, baton,
113                                set_read_only, apr_pool_cleanup_null);
114
115      /* Finally, allow write access (undoing it has already been scheduled
116         and is idempotent). */
117      SVN_ERR(svn_io_set_file_read_write(path, FALSE, scratch_pool));
118    }
119
120  return SVN_NO_ERROR;
121}
122
123/* Core implementation of svn_fs_fs__open_pack_or_rev_file working on an
124 * existing, initialized FILE structure.  If WRITABLE is TRUE, give write
125 * access to the file - temporarily resetting the r/o state if necessary.
126 */
127static svn_error_t *
128open_pack_or_rev_file(svn_fs_fs__revision_file_t *file,
129                      svn_fs_t *fs,
130                      svn_revnum_t rev,
131                      svn_boolean_t writable,
132                      apr_pool_t *result_pool,
133                      apr_pool_t *scratch_pool)
134{
135  fs_fs_data_t *ffd = fs->fsap_data;
136  svn_error_t *err;
137  svn_boolean_t retry = FALSE;
138
139  do
140    {
141      const char *path = svn_fs_fs__path_rev_absolute(fs, rev, scratch_pool);
142      apr_file_t *apr_file;
143      apr_int32_t flags = writable
144                        ? APR_READ | APR_WRITE | APR_BUFFERED
145                        : APR_READ | APR_BUFFERED;
146
147      /* We may have to *temporarily* enable write access. */
148      err = writable ? auto_make_writable(path, result_pool, scratch_pool)
149                     : SVN_NO_ERROR;
150
151      /* open the revision file in buffered r/o or r/w mode */
152      if (!err)
153        err = svn_io_file_open(&apr_file, path, flags, APR_OS_DEFAULT,
154                               result_pool);
155
156      if (!err)
157        {
158          file->file = apr_file;
159          file->stream = svn_stream_from_aprfile2(apr_file, TRUE,
160                                                  result_pool);
161          file->is_packed = svn_fs_fs__is_packed_rev(fs, rev);
162
163          return SVN_NO_ERROR;
164        }
165
166      if (err && APR_STATUS_IS_ENOENT(err->apr_err))
167        {
168          if (ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
169            {
170              /* Could not open the file. This may happen if the
171               * file once existed but got packed later. */
172              svn_error_clear(err);
173
174              /* if that was our 2nd attempt, leave it at that. */
175              if (retry)
176                return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
177                                         _("No such revision %ld"), rev);
178
179              /* We failed for the first time. Refresh cache & retry. */
180              SVN_ERR(svn_fs_fs__update_min_unpacked_rev(fs, scratch_pool));
181              file->start_revision = svn_fs_fs__packed_base_rev(fs, rev);
182
183              retry = TRUE;
184            }
185          else
186            {
187              svn_error_clear(err);
188              return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
189                                       _("No such revision %ld"), rev);
190            }
191        }
192      else
193        {
194          retry = FALSE;
195        }
196    }
197  while (retry);
198
199  return svn_error_trace(err);
200}
201
202svn_error_t *
203svn_fs_fs__open_pack_or_rev_file(svn_fs_fs__revision_file_t **file,
204                                 svn_fs_t *fs,
205                                 svn_revnum_t rev,
206                                 apr_pool_t *result_pool,
207                                 apr_pool_t *scratch_pool)
208{
209  *file = apr_palloc(result_pool, sizeof(**file));
210  init_revision_file(*file, fs, rev, result_pool);
211
212  return svn_error_trace(open_pack_or_rev_file(*file, fs, rev, FALSE,
213                                               result_pool, scratch_pool));
214}
215
216svn_error_t *
217svn_fs_fs__open_pack_or_rev_file_writable(svn_fs_fs__revision_file_t** file,
218                                          svn_fs_t* fs,
219                                          svn_revnum_t rev,
220                                          apr_pool_t* result_pool,
221                                          apr_pool_t *scratch_pool)
222{
223  *file = apr_palloc(result_pool, sizeof(**file));
224  init_revision_file(*file, fs, rev, result_pool);
225
226  return svn_error_trace(open_pack_or_rev_file(*file, fs, rev, TRUE,
227                                               result_pool, scratch_pool));
228}
229
230svn_error_t *
231svn_fs_fs__auto_read_footer(svn_fs_fs__revision_file_t *file)
232{
233  if (file->l2p_offset == -1)
234    {
235      apr_off_t filesize = 0;
236      unsigned char footer_length;
237      svn_stringbuf_t *footer;
238
239      /* Determine file size. */
240      SVN_ERR(svn_io_file_seek(file->file, APR_END, &filesize, file->pool));
241
242      /* Read last byte (containing the length of the footer). */
243      SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
244                                       filesize - 1, file->pool));
245      SVN_ERR(svn_io_file_read_full2(file->file, &footer_length,
246                                     sizeof(footer_length), NULL, NULL,
247                                     file->pool));
248
249      /* Read footer. */
250      footer = svn_stringbuf_create_ensure(footer_length, file->pool);
251      SVN_ERR(svn_io_file_aligned_seek(file->file, file->block_size, NULL,
252                                       filesize - 1 - footer_length,
253                                       file->pool));
254      SVN_ERR(svn_io_file_read_full2(file->file, footer->data, footer_length,
255                                     &footer->len, NULL, file->pool));
256      footer->data[footer->len] = '\0';
257
258      /* Extract index locations. */
259      SVN_ERR(svn_fs_fs__parse_footer(&file->l2p_offset, &file->l2p_checksum,
260                                      &file->p2l_offset, &file->p2l_checksum,
261                                      footer, file->start_revision,
262                                      filesize - footer_length - 1,
263                                      file->pool));
264      file->footer_offset = filesize - footer_length - 1;
265    }
266
267  return SVN_NO_ERROR;
268}
269
270svn_error_t *
271svn_fs_fs__open_proto_rev_file(svn_fs_fs__revision_file_t **file,
272                               svn_fs_t *fs,
273                               const svn_fs_fs__id_part_t *txn_id,
274                               apr_pool_t* result_pool,
275                               apr_pool_t *scratch_pool)
276{
277  apr_file_t *apr_file;
278  SVN_ERR(svn_io_file_open(&apr_file,
279                           svn_fs_fs__path_txn_proto_rev(fs, txn_id,
280                                                         scratch_pool),
281                           APR_READ | APR_BUFFERED, APR_OS_DEFAULT,
282                           result_pool));
283
284  *file = apr_pcalloc(result_pool, sizeof(**file));
285  (*file)->file = apr_file;
286  (*file)->is_packed = FALSE;
287  (*file)->start_revision = SVN_INVALID_REVNUM;
288  (*file)->stream = svn_stream_from_aprfile2(apr_file, TRUE, result_pool);
289
290  return SVN_NO_ERROR;
291}
292
293svn_error_t *
294svn_fs_fs__close_revision_file(svn_fs_fs__revision_file_t *file)
295{
296  if (file->stream)
297    SVN_ERR(svn_stream_close(file->stream));
298  if (file->file)
299    SVN_ERR(svn_io_file_close(file->file, file->pool));
300
301  file->file = NULL;
302  file->stream = NULL;
303  file->l2p_stream = NULL;
304  file->p2l_stream = NULL;
305
306  return SVN_NO_ERROR;
307}
308