ovsdb: Correctly implement conditions that include multiple clauses.
[openvswitch] / ovsdb / log.c
1 /* Copyright (c) 2009, 2010, 2011 Nicira Networks
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17
18 #include "log.h"
19
20 #include <assert.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <unistd.h>
27
28 #include "json.h"
29 #include "lockfile.h"
30 #include "ovsdb.h"
31 #include "ovsdb-error.h"
32 #include "sha1.h"
33 #include "socket-util.h"
34 #include "transaction.h"
35 #include "util.h"
36 #include "vlog.h"
37
38 VLOG_DEFINE_THIS_MODULE(ovsdb_log);
39
40 enum ovsdb_log_mode {
41     OVSDB_LOG_READ,
42     OVSDB_LOG_WRITE
43 };
44
45 struct ovsdb_log {
46     off_t prev_offset;
47     off_t offset;
48     char *name;
49     struct lockfile *lockfile;
50     FILE *stream;
51     struct ovsdb_error *read_error;
52     struct ovsdb_error *write_error;
53     enum ovsdb_log_mode mode;
54 };
55
56 /* Attempts to open 'name' with the specified 'open_mode'.  On success, stores
57  * the new log into '*filep' and returns NULL; otherwise returns NULL and
58  * stores NULL into '*filep'.
59  *
60  * Whether the file will be locked using lockfile_lock() depends on 'locking':
61  * use true to lock it, false not to lock it, or -1 to lock it only if
62  * 'open_mode' is a mode that allows writing.
63  */
64 struct ovsdb_error *
65 ovsdb_log_open(const char *name, enum ovsdb_log_open_mode open_mode,
66                int locking, struct ovsdb_log **filep)
67 {
68     struct lockfile *lockfile;
69     struct ovsdb_error *error;
70     struct ovsdb_log *file;
71     struct stat s;
72     FILE *stream;
73     int flags;
74     int fd;
75
76     *filep = NULL;
77
78     assert(locking == -1 || locking == false || locking == true);
79     if (locking < 0) {
80         locking = open_mode != OVSDB_LOG_READ_ONLY;
81     }
82     if (locking) {
83         int retval = lockfile_lock(name, 0, &lockfile);
84         if (retval) {
85             error = ovsdb_io_error(retval, "%s: failed to lock lockfile",
86                                    name);
87             goto error;
88         }
89     } else {
90         lockfile = NULL;
91     }
92
93     if (open_mode == OVSDB_LOG_READ_ONLY) {
94         flags = O_RDONLY;
95     } else if (open_mode == OVSDB_LOG_READ_WRITE) {
96         flags = O_RDWR;
97     } else if (open_mode == OVSDB_LOG_CREATE) {
98         flags = O_RDWR | O_CREAT | O_EXCL;
99     } else {
100         NOT_REACHED();
101     }
102     fd = open(name, flags, 0666);
103     if (fd < 0) {
104         const char *op = open_mode == OVSDB_LOG_CREATE ? "create" : "open";
105         error = ovsdb_io_error(errno, "%s: %s failed", op, name);
106         goto error_unlock;
107     }
108
109     if (!fstat(fd, &s) && s.st_size == 0) {
110         /* It's (probably) a new file so fsync() its parent directory to ensure
111          * that its directory entry is committed to disk. */
112         fsync_parent_dir(name);
113     }
114
115     stream = fdopen(fd, open_mode == OVSDB_LOG_READ_ONLY ? "rb" : "w+b");
116     if (!stream) {
117         error = ovsdb_io_error(errno, "%s: fdopen failed", name);
118         goto error_close;
119     }
120
121     file = xmalloc(sizeof *file);
122     file->name = xstrdup(name);
123     file->lockfile = lockfile;
124     file->stream = stream;
125     file->prev_offset = 0;
126     file->offset = 0;
127     file->read_error = NULL;
128     file->write_error = NULL;
129     file->mode = OVSDB_LOG_READ;
130     *filep = file;
131     return NULL;
132
133 error_close:
134     close(fd);
135 error_unlock:
136     lockfile_unlock(lockfile);
137 error:
138     return error;
139 }
140
141 void
142 ovsdb_log_close(struct ovsdb_log *file)
143 {
144     if (file) {
145         free(file->name);
146         fclose(file->stream);
147         lockfile_unlock(file->lockfile);
148         ovsdb_error_destroy(file->read_error);
149         ovsdb_error_destroy(file->write_error);
150         free(file);
151     }
152 }
153
154 static const char magic[] = "OVSDB JSON ";
155
156 static bool
157 parse_header(char *header, unsigned long int *length,
158              uint8_t sha1[SHA1_DIGEST_SIZE])
159 {
160     char *p;
161
162     /* 'header' must consist of a magic string... */
163     if (strncmp(header, magic, strlen(magic))) {
164         return false;
165     }
166
167     /* ...followed by a length in bytes... */
168     *length = strtoul(header + strlen(magic), &p, 10);
169     if (!*length || *length == ULONG_MAX || *p != ' ') {
170         return false;
171     }
172     p++;
173
174     /* ...followed by a SHA-1 hash... */
175     if (!sha1_from_hex(sha1, p)) {
176         return false;
177     }
178     p += SHA1_HEX_DIGEST_LEN;
179
180     /* ...and ended by a new-line. */
181     if (*p != '\n') {
182         return false;
183     }
184
185     return true;
186 }
187
188 struct ovsdb_log_read_cbdata {
189     char input[4096];
190     struct ovsdb_log *file;
191     int error;
192     unsigned long length;
193 };
194
195 static struct ovsdb_error *
196 parse_body(struct ovsdb_log *file, off_t offset, unsigned long int length,
197            uint8_t sha1[SHA1_DIGEST_SIZE], struct json **jsonp)
198 {
199     struct json_parser *parser;
200     struct sha1_ctx ctx;
201
202     sha1_init(&ctx);
203     parser = json_parser_create(JSPF_TRAILER);
204
205     while (length > 0) {
206         char input[BUFSIZ];
207         int chunk;
208
209         chunk = MIN(length, sizeof input);
210         if (fread(input, 1, chunk, file->stream) != chunk) {
211             json_parser_abort(parser);
212             return ovsdb_io_error(ferror(file->stream) ? errno : EOF,
213                                   "%s: error reading %lu bytes "
214                                   "starting at offset %lld", file->name,
215                                   length, (long long int) offset);
216         }
217         sha1_update(&ctx, input, chunk);
218         json_parser_feed(parser, input, chunk);
219         length -= chunk;
220     }
221
222     sha1_final(&ctx, sha1);
223     *jsonp = json_parser_finish(parser);
224     return NULL;
225 }
226
227 struct ovsdb_error *
228 ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp)
229 {
230     uint8_t expected_sha1[SHA1_DIGEST_SIZE];
231     uint8_t actual_sha1[SHA1_DIGEST_SIZE];
232     struct ovsdb_error *error;
233     off_t data_offset;
234     unsigned long data_length;
235     struct json *json;
236     char header[128];
237
238     *jsonp = json = NULL;
239
240     if (file->read_error) {
241         return ovsdb_error_clone(file->read_error);
242     } else if (file->mode == OVSDB_LOG_WRITE) {
243         return OVSDB_BUG("reading file in write mode");
244     }
245
246     if (!fgets(header, sizeof header, file->stream)) {
247         if (feof(file->stream)) {
248             error = NULL;
249         } else {
250             error = ovsdb_io_error(errno, "%s: read failed", file->name);
251         }
252         goto error;
253     }
254
255     if (!parse_header(header, &data_length, expected_sha1)) {
256         error = ovsdb_syntax_error(NULL, NULL, "%s: parse error at offset "
257                                    "%lld in header line \"%.*s\"",
258                                    file->name, (long long int) file->offset,
259                                    (int) strcspn(header, "\n"), header);
260         goto error;
261     }
262
263     data_offset = file->offset + strlen(header);
264     error = parse_body(file, data_offset, data_length, actual_sha1, &json);
265     if (error) {
266         goto error;
267     }
268
269     if (memcmp(expected_sha1, actual_sha1, SHA1_DIGEST_SIZE)) {
270         error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
271                                    "offset %lld have SHA-1 hash "SHA1_FMT" "
272                                    "but should have hash "SHA1_FMT,
273                                    file->name, data_length,
274                                    (long long int) data_offset,
275                                    SHA1_ARGS(actual_sha1),
276                                    SHA1_ARGS(expected_sha1));
277         goto error;
278     }
279
280     if (json->type == JSON_STRING) {
281         error = ovsdb_syntax_error(NULL, NULL, "%s: %lu bytes starting at "
282                                    "offset %lld are not valid JSON (%s)",
283                                    file->name, data_length,
284                                    (long long int) data_offset,
285                                    json->u.string);
286         goto error;
287     }
288
289     file->prev_offset = file->offset;
290     file->offset = data_offset + data_length;
291     *jsonp = json;
292     return NULL;
293
294 error:
295     file->read_error = ovsdb_error_clone(error);
296     json_destroy(json);
297     return error;
298 }
299
300 /* Causes the log record read by the previous call to ovsdb_log_read() to be
301  * effectively discarded.  The next call to ovsdb_log_write() will overwrite
302  * that previously read record.
303  *
304  * Calling this function more than once has no additional effect.
305  *
306  * This function is useful when ovsdb_log_read() successfully reads a record
307  * but that record does not make sense at a higher level (e.g. it specifies an
308  * invalid transaction). */
309 void
310 ovsdb_log_unread(struct ovsdb_log *file)
311 {
312     assert(file->mode == OVSDB_LOG_READ);
313     file->offset = file->prev_offset;
314 }
315
316 struct ovsdb_error *
317 ovsdb_log_write(struct ovsdb_log *file, struct json *json)
318 {
319     uint8_t sha1[SHA1_DIGEST_SIZE];
320     struct ovsdb_error *error;
321     char *json_string;
322     char header[128];
323     size_t length;
324
325     json_string = NULL;
326
327     if (file->write_error) {
328         return ovsdb_error_clone(file->write_error);
329     } else if (file->mode == OVSDB_LOG_READ) {
330         file->mode = OVSDB_LOG_WRITE;
331         if (fseeko(file->stream, file->offset, SEEK_SET)) {
332             error = ovsdb_io_error(errno, "%s: cannot seek to offset %lld",
333                                    file->name, (long long int) file->offset);
334             goto error;
335         }
336         if (ftruncate(fileno(file->stream), file->offset)) {
337             error = ovsdb_io_error(errno, "%s: cannot truncate to length %lld",
338                                    file->name, (long long int) file->offset);
339             goto error;
340         }
341     }
342
343     if (json->type != JSON_OBJECT && json->type != JSON_ARRAY) {
344         error = OVSDB_BUG("bad JSON type");
345         goto error;
346     }
347
348     /* Compose content.  Add a new-line (replacing the null terminator) to make
349      * the file easier to read, even though it has no semantic value.  */
350     json_string = json_to_string(json, 0);
351     length = strlen(json_string) + 1;
352     json_string[length - 1] = '\n';
353
354     /* Compose header. */
355     sha1_bytes(json_string, length, sha1);
356     snprintf(header, sizeof header, "%s%zu "SHA1_FMT"\n",
357              magic, length, SHA1_ARGS(sha1));
358
359     /* Write. */
360     if (fwrite(header, strlen(header), 1, file->stream) != 1
361         || fwrite(json_string, length, 1, file->stream) != 1
362         || fflush(file->stream))
363     {
364         error = ovsdb_io_error(errno, "%s: write failed", file->name);
365
366         /* Remove any partially written data, ignoring errors since there is
367          * nothing further we can do. */
368         ignore(ftruncate(fileno(file->stream), file->offset));
369
370         goto error;
371     }
372
373     file->offset += strlen(header) + length;
374     free(json_string);
375     return NULL;
376
377 error:
378     file->write_error = ovsdb_error_clone(error);
379     free(json_string);
380     return error;
381 }
382
383 struct ovsdb_error *
384 ovsdb_log_commit(struct ovsdb_log *file)
385 {
386     if (fsync(fileno(file->stream))) {
387         return ovsdb_io_error(errno, "%s: fsync failed", file->name);
388     }
389     return NULL;
390 }
391
392 /* Returns the current offset into the file backing 'log', in bytes.  This
393  * reflects the number of bytes that have been read or written in the file.  If
394  * the whole file has been read, this is the file size. */
395 off_t
396 ovsdb_log_get_offset(const struct ovsdb_log *log)
397 {
398     return log->offset;
399 }