efidp.c (64f77f095e452277a28de084392614bce56ac9c3) efidp.c (693ba58ff67a9146bab22a71900b44b3bf79e7bb)
1/*-
2 * Copyright (c) 2016 Netflix, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 17 unchanged lines hidden (view full) ---

26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30#include <ctype.h>
31#include <efivar.h>
32#include <efivar-dp.h>
33#include <err.h>
1/*-
2 * Copyright (c) 2016 Netflix, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 17 unchanged lines hidden (view full) ---

26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30#include <ctype.h>
31#include <efivar.h>
32#include <efivar-dp.h>
33#include <err.h>
34#include <errno.h>
34#include <getopt.h>
35#include <stddef.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <unistd.h>
40
41#define MAXSIZE 65536 /* Everyting will be smaller than this, most 1000x smaller */
42
43/* options descriptor */
44static struct option longopts[] = {
35#include <getopt.h>
36#include <stddef.h>
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <unistd.h>
41
42#define MAXSIZE 65536 /* Everyting will be smaller than this, most 1000x smaller */
43
44/* options descriptor */
45static struct option longopts[] = {
46 { "to-unix", no_argument, NULL, 'u' },
47 { "to-efi", no_argument, NULL, 'e' },
45 { "format", no_argument, NULL, 'f' },
46 { "parse", no_argument, NULL, 'p' },
47 { NULL, 0, NULL, 0 }
48};
49
50
48 { "format", no_argument, NULL, 'f' },
49 { "parse", no_argument, NULL, 'p' },
50 { NULL, 0, NULL, 0 }
51};
52
53
51static int flag_format, flag_parse;
54static int flag_format, flag_parse, flag_unix, flag_efi;
52
53static void
54usage(void)
55{
56
55
56static void
57usage(void)
58{
59
57 errx(1, "efidp [-fp]");
60 errx(1, "efidp [-efpu]");
58}
59
60static ssize_t
61read_file(int fd, void **rv)
62{
63 uint8_t *retval;
64 size_t len;
65 off_t off;

--- 15 unchanged lines hidden (view full) ---

81 return off;
82}
83
84static void
85parse_args(int argc, char **argv)
86{
87 int ch;
88
61}
62
63static ssize_t
64read_file(int fd, void **rv)
65{
66 uint8_t *retval;
67 size_t len;
68 off_t off;

--- 15 unchanged lines hidden (view full) ---

84 return off;
85}
86
87static void
88parse_args(int argc, char **argv)
89{
90 int ch;
91
89 while ((ch = getopt_long(argc, argv, "fp",
92 while ((ch = getopt_long(argc, argv, "efpu",
90 longopts, NULL)) != -1) {
91 switch (ch) {
93 longopts, NULL)) != -1) {
94 switch (ch) {
95 case 'e':
96 flag_efi++;
97 break;
92 case 'f':
93 flag_format++;
94 break;
95 case 'p':
96 flag_parse++;
97 break;
98 case 'f':
99 flag_format++;
100 break;
101 case 'p':
102 flag_parse++;
103 break;
104 case 'u':
105 flag_unix++;
106 break;
98 default:
99 usage();
100 }
101 }
102 argc -= optind;
103 argv += optind;
104
105 if (argc >= 1)
106 usage();
107
107 default:
108 usage();
109 }
110 }
111 argc -= optind;
112 argv += optind;
113
114 if (argc >= 1)
115 usage();
116
108 if (flag_parse + flag_format != 1) {
117 if (flag_parse + flag_format + flag_efi + flag_unix != 1) {
109 warnx("Can only use one of -p (--parse), "
110 "and -f (--format)");
111 usage();
112 }
113}
114
115static char *
116trim(char *s)
117{
118 char *t;
119
120 while (isspace(*s))
121 s++;
122 t = s + strlen(s) - 1;
123 while (t > s && isspace(*t))
124 *t-- = '\0';
125 return s;
126}
127
118 warnx("Can only use one of -p (--parse), "
119 "and -f (--format)");
120 usage();
121 }
122}
123
124static char *
125trim(char *s)
126{
127 char *t;
128
129 while (isspace(*s))
130 s++;
131 t = s + strlen(s) - 1;
132 while (t > s && isspace(*t))
133 *t-- = '\0';
134 return s;
135}
136
128int
129main(int argc, char **argv)
137static void
138unix_to_efi(void)
130{
131 char buffer[MAXSIZE];
139{
140 char buffer[MAXSIZE];
141 char efi[MAXSIZE];
142 efidp dp;
143 char *walker;
144 int rv;
132
145
133 parse_args(argc, argv);
134 if (flag_format) {
135 ssize_t fmtlen;
136 ssize_t len;
137 void *data;
138 size_t dplen;
139 const_efidp dp;
140
141 len = read_file(STDIN_FILENO, &data);
142 if (len == -1)
143 err(1, "read");
144 dp = (const_efidp)data;
145 while (len > 0) {
146 dplen = efidp_size(dp);
147 fmtlen = efidp_format_device_path(buffer, sizeof(buffer),
148 dp, dplen);
149 if (fmtlen > 0)
150 printf("%s\n", buffer);
151 len -= dplen;
152 dp = (const_efidp)((const char *)dp + dplen);
146 while (fgets(buffer, sizeof(buffer), stdin)) {
147 walker= trim(buffer);
148 rv = efivar_unix_path_to_device_path(walker, &dp);
149 if (rv != 0) {
150 errno = rv;
151 warn("Can't convert '%s' to efi", walker);
152 continue;
153 }
153 }
154 free(data);
155 } else if (flag_parse) {
156 efidp dp;
157 ssize_t dplen;
158 char *walker;
154 if (efidp_format_device_path(efi, sizeof(efi),
155 dp, efidp_size(dp)) < 0) {
156 warnx("Can't format dp for '%s'", walker);
157 continue;
158 }
159 printf("%s\n", efi);
160 }
161}
159
162
160 dplen = MAXSIZE;
161 dp = malloc(dplen);
162 if (dp == NULL)
163 errx(1, "Can't allocate memory.");
164 while (fgets(buffer, sizeof(buffer), stdin)) {
165 walker= trim(buffer);
166 dplen = efidp_parse_device_path(walker, dp, dplen);
167 if (dplen == -1)
168 errx(1, "Can't parse %s", walker);
169 write(STDOUT_FILENO, dp, dplen);
163static void
164efi_to_unix(void)
165{
166 char buffer[MAXSIZE];
167 char dpbuf[MAXSIZE];
168 efidp dp;
169 size_t dplen;
170 char *walker, *dev, *relpath, *abspath;
171 int rv;
172
173 dp = (efidp)dpbuf;
174 while (fgets(buffer, sizeof(buffer), stdin)) {
175 walker= trim(buffer);
176 dplen = efidp_parse_device_path(walker, dp, sizeof(dpbuf));
177 rv = efivar_device_path_to_unix_path(dp, &dev, &relpath, &abspath);
178 if (rv == 0)
179 printf("%s:%s %s\n", dev, relpath, abspath);
180 else {
181 errno = rv;
182 warn("Can't convert '%s' to unix", walker);
170 }
183 }
171 free(dp);
172 }
173}
184 }
185}
186
187static void
188format(void)
189{
190 char buffer[MAXSIZE];
191 ssize_t fmtlen;
192 ssize_t len;
193 void *data;
194 size_t dplen;
195 const_efidp dp;
196
197 len = read_file(STDIN_FILENO, &data);
198 if (len == -1)
199 err(1, "read");
200 dp = (const_efidp)data;
201 while (len > 0) {
202 dplen = efidp_size(dp);
203 fmtlen = efidp_format_device_path(buffer, sizeof(buffer),
204 dp, dplen);
205 if (fmtlen > 0)
206 printf("%s\n", buffer);
207 len -= dplen;
208 dp = (const_efidp)((const char *)dp + dplen);
209 }
210 free(data);
211}
212
213static void
214parse(void)
215{
216 char buffer[MAXSIZE];
217 efidp dp;
218 ssize_t dplen;
219 char *walker;
220
221 dplen = MAXSIZE;
222 dp = malloc(dplen);
223 if (dp == NULL)
224 errx(1, "Can't allocate memory.");
225 while (fgets(buffer, sizeof(buffer), stdin)) {
226 walker= trim(buffer);
227 dplen = efidp_parse_device_path(walker, dp, dplen);
228 if (dplen == -1)
229 errx(1, "Can't parse %s", walker);
230 write(STDOUT_FILENO, dp, dplen);
231 }
232 free(dp);
233}
234
235int
236main(int argc, char **argv)
237{
238
239 parse_args(argc, argv);
240 if (flag_unix)
241 efi_to_unix();
242 else if (flag_efi)
243 unix_to_efi();
244 else if (flag_format)
245 format();
246 else if (flag_parse)
247 parse();
248}