1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#include <fcntl.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "types/types.h"
#include <log/log.h>
#include <talloc/talloc.h>
#include "device-handler.h"
#include "parser.h"
#include "parser-utils.h"
#include "paths.h"
struct parser __grub2_parser;
struct parser __kboot_parser;
struct parser __native_parser;
struct parser __yaboot_parser;
static const struct parser *const parsers[] = {
// &__native_parser,
&__kboot_parser,
&__grub2_parser,
&__yaboot_parser,
NULL
};
static const int max_file_size = 1024 * 1024;
static int read_file(struct discover_context *ctx,
const char *filename, char **bufp, int *lenp)
{
struct stat statbuf;
int rc, fd, i, len;
char *buf;
fd = open(filename, O_RDONLY);
if (fd < 0)
return -1;
rc = fstat(fd, &statbuf);
if (rc < 0)
goto err_close;
len = statbuf.st_size;
if (len > max_file_size)
goto err_close;
buf = talloc_array(ctx, char, len);
if (!buf)
goto err_close;
for (i = 0; i < len; i += rc) {
rc = read(fd, buf + i, len - i);
/* unexpected EOF: trim and return */
if (rc == 0) {
len = i;
break;
}
if (rc < 0)
goto err_free;
}
close(fd);
*bufp = buf;
*lenp = len;
return 0;
err_free:
talloc_free(buf);
err_close:
close(fd);
return -1;
}
static void iterate_parser_files(struct discover_context *ctx,
const struct parser *parser)
{
const char * const *filename;
const char *path, *url;
unsigned int tempfile;
if (!parser->filenames)
return;
for (filename = parser->filenames; *filename; filename++) {
int rc, len;
char *buf;
url = resolve_path(ctx, *filename, ctx->device->device_path);
if (!url)
continue;
path = load_file(ctx, url, &tempfile);
if (!path)
continue;
rc = read_file(ctx, path, &buf, &len);
if (!rc) {
parser->parse(ctx, buf, len);
talloc_free(buf);
}
if (tempfile)
unlink(path);
}
}
void iterate_parsers(struct discover_context *ctx)
{
int i;
pb_log("trying parsers for %s\n", ctx->device->device->id);
for (i = 0; parsers[i]; i++) {
pb_log("\ttrying parser '%s'\n", parsers[i]->name);
iterate_parser_files(ctx, parsers[i]);
}
}
void parser_init(void)
{
}
|
