1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <inttypes.h>
18 #include <stdint.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 
23 #include <hardware/nvram.h>
24 
25 #define countof(array) (sizeof(array) / sizeof((array)[0]))
26 
27 // Exit status codes. These are all negative as the positive ones are used for
28 // the NV_RESULT_ codes.
29 enum StatusCode {
30   kStatusInvalidArg = -1,
31   kStatusHALError = -2,
32   kStatusAllocationFailure = -3,
33 };
34 
35 static struct {
36   int status;
37   const char* description;
38 } kStatusStringTable[] = {
39     {kStatusInvalidArg, "Bad parameter"},
40     {kStatusHALError, "NVRAM HAL initialization error"},
41     {kStatusAllocationFailure, "Memory allocation error"},
42     {NV_RESULT_SUCCESS, "Success"},
43     {NV_RESULT_INTERNAL_ERROR, "Internal error"},
44     {NV_RESULT_ACCESS_DENIED, "Access denied"},
45     {NV_RESULT_INVALID_PARAMETER, "Invalid NVRAM parameter"},
46     {NV_RESULT_SPACE_DOES_NOT_EXIST, "Space does not exist"},
47     {NV_RESULT_SPACE_ALREADY_EXISTS, "Space already exists"},
48     {NV_RESULT_OPERATION_DISABLED, "Operation disabled"},
49 };
50 
51 // Returns a string describing |status|.
52 static const char* StatusToString(int status) {
53   for (size_t i = 0; i < countof(kStatusStringTable); ++i) {
54     if (kStatusStringTable[i].status == status) {
55       return kStatusStringTable[i].description;
56     }
57   }
58 
59   return "unknown error";
60 }
61 
62 // A table mapping control values to names.
63 static struct {
64   nvram_control_t control;
65   const char* name;
66 } kControlNameTable[] = {
67     {NV_CONTROL_PERSISTENT_WRITE_LOCK, "PERSISTENT_WRITE_LOCK"},
68     {NV_CONTROL_BOOT_WRITE_LOCK, "BOOT_WRITE_LOCK"},
69     {NV_CONTROL_BOOT_READ_LOCK, "BOOT_READ_LOCK"},
70     {NV_CONTROL_WRITE_AUTHORIZATION, "WRITE_AUTHORIZATION"},
71     {NV_CONTROL_READ_AUTHORIZATION, "READ_AUTHORIZATION"},
72     {NV_CONTROL_WRITE_EXTEND, "WRITE_EXTEND"},
73 };
74 
75 // Returns the string representation of |control|, or NULL if |control| isn't a
76 // valid control value.
77 static const char* ControlToString(nvram_control_t control) {
78   for (size_t i = 0; i < countof(kControlNameTable); ++i) {
79     if (kControlNameTable[i].control == control) {
80       return kControlNameTable[i].name;
81     }
82   }
83 
84   return NULL;
85 }
86 
87 // Sets |control| to the NV_CONTROL_ value corresponding to the string control
88 // representation found in |name|. Returns 0 if successful, 1 if name doesn't
89 // match any control string.
90 static int StringToControl(const char* name, nvram_control_t* control) {
91   for (size_t i = 0; i < countof(kControlNameTable); ++i) {
92     if (strcmp(kControlNameTable[i].name, name) == 0) {
93       *control = kControlNameTable[i].control;
94       return 0;
95     }
96   }
97 
98   return 1;
99 }
100 
101 static int HandleGetTotalSize(nvram_device_t* device, char* args[]) {
102   (void)args;
103   uint64_t total_size = 0;
104   nvram_result_t result = device->get_total_size_in_bytes(device, &total_size);
105   if (result != NV_RESULT_SUCCESS) {
106     return result;
107   }
108 
109   printf("%" PRIu64 "\n", total_size);
110   return 0;
111 }
112 
113 static int HandleGetAvailableSize(nvram_device_t* device, char* args[]) {
114   (void)args;
115   uint64_t available_size = 0;
116   nvram_result_t result =
117       device->get_available_size_in_bytes(device, &available_size);
118   if (result != NV_RESULT_SUCCESS) {
119     return result;
120   }
121 
122   printf("%" PRIu64 "\n", available_size);
123   return 0;
124 }
125 
126 static int HandleGetMaxSpaceSize(nvram_device_t* device, char* args[]) {
127   (void)args;
128   uint64_t max_space_size = 0;
129   nvram_result_t result =
130       device->get_max_space_size_in_bytes(device, &max_space_size);
131   if (result != NV_RESULT_SUCCESS) {
132     return result;
133   }
134 
135   printf("%" PRIu64 "\n", max_space_size);
136   return 0;
137 }
138 
139 static int HandleGetMaxSpaces(nvram_device_t* device, char* args[]) {
140   (void)args;
141   uint32_t max_spaces = 0;
142   nvram_result_t result = device->get_max_spaces(device, &max_spaces);
143   if (result != NV_RESULT_SUCCESS) {
144     return result;
145   }
146 
147   printf("%" PRIu32 "\n", max_spaces);
148   return 0;
149 }
150 
151 static int HandleGetSpaceList(nvram_device_t* device, char* args[]) {
152   (void)args;
153   uint32_t list_size = 0;
154   nvram_result_t result = device->get_space_list(device, 0, NULL, &list_size);
155   if (result != NV_RESULT_SUCCESS) {
156     return result;
157   }
158 
159   uint32_t* space_index_list = calloc(list_size, sizeof(uint32_t));
160   if (!space_index_list) {
161     return kStatusAllocationFailure;
162   }
163 
164   result =
165       device->get_space_list(device, list_size, space_index_list, &list_size);
166   if (result != NV_RESULT_SUCCESS) {
167     free(space_index_list);
168     return result;
169   }
170 
171   for (uint32_t i = 0; i < list_size; ++i) {
172     if (i != 0) {
173       fputs(",", stdout);
174     }
175     printf("%" PRIu32, space_index_list[i]);
176   }
177   fputs("\n", stdout);
178 
179   free(space_index_list);
180   return 0;
181 }
182 
183 static int HandleGetSpaceSize(nvram_device_t* device, char* args[]) {
184   uint32_t index = strtoul(args[0], NULL, 0);
185   uint64_t space_size = 0;
186   nvram_result_t result = device->get_space_size(device, index, &space_size);
187   if (result != NV_RESULT_SUCCESS) {
188     return result;
189   }
190 
191   printf("%" PRIu64 "\n", space_size);
192   return 0;
193 }
194 
195 static int HandleGetSpaceControls(nvram_device_t* device, char* args[]) {
196   uint32_t index = strtoul(args[0], NULL, 0);
197   uint32_t list_size = 0;
198   nvram_result_t result =
199       device->get_space_controls(device, index, 0, NULL, &list_size);
200   if (result != NV_RESULT_SUCCESS) {
201     return result;
202   }
203 
204   uint32_t* controls_list = calloc(list_size, sizeof(nvram_control_t));
205   if (!controls_list) {
206     return kStatusAllocationFailure;
207   }
208 
209   result = device->get_space_controls(device, index, list_size, controls_list,
210                                       &list_size);
211   if (result != NV_RESULT_SUCCESS) {
212     free(controls_list);
213     return result;
214   }
215 
216   for (uint32_t i = 0; i < list_size; ++i) {
217     if (i != 0) {
218       fputs(",", stdout);
219     }
220     const char* name = ControlToString(controls_list[i]);
221     if (name) {
222       fputs(name, stdout);
223     } else {
224       printf("<unknown_control_%" PRIu32 ">", controls_list[i]);
225     }
226   }
227   fputs("", stdout);
228 
229   free(controls_list);
230   return 0;
231 }
232 
233 static int HandleIsSpaceReadLocked(nvram_device_t* device, char* args[]) {
234   uint32_t index = strtoul(args[0], NULL, 0);
235   int read_locked = 0;
236   int write_locked = 0;
237   nvram_result_t result =
238       device->is_space_locked(device, index, &read_locked, &write_locked);
239   if (result != NV_RESULT_SUCCESS) {
240     return result;
241   }
242 
243   printf("%d\n", read_locked);
244   return 0;
245 }
246 
247 static int HandleIsSpaceWriteLocked(nvram_device_t* device, char* args[]) {
248   uint32_t index = strtoul(args[0], NULL, 0);
249   int read_locked = 0;
250   int write_locked = 0;
251   nvram_result_t result =
252       device->is_space_locked(device, index, &read_locked, &write_locked);
253   if (result != NV_RESULT_SUCCESS) {
254     return result;
255   }
256 
257   printf("%d\n", write_locked);
258   return 0;
259 }
260 
261 static int HandleCreateSpace(nvram_device_t* device, char* args[]) {
262   uint32_t index = strtoul(args[0], NULL, 0);
263   uint64_t size = strtoull(args[1], NULL, 0);
264   uint32_t list_size = 0;
265   nvram_control_t* controls_list = NULL;
266   char* tail = args[2];
267   while (tail) {
268     ++list_size;
269     nvram_control_t* new_controls_list =
270         realloc(controls_list, sizeof(nvram_control_t) * list_size);
271     if (new_controls_list) {
272       controls_list = new_controls_list;
273     } else {
274       free(controls_list);
275       return kStatusAllocationFailure;
276     }
277 
278     if (StringToControl(strsep(&tail, ","), &(controls_list[list_size - 1]))) {
279       free(controls_list);
280       return kStatusInvalidArg;
281     }
282   }
283 
284   return device->create_space(device, index, size, controls_list, list_size,
285                               (uint8_t*)args[3], strlen(args[3]));
286 }
287 
288 static int HandleDeleteSpace(nvram_device_t* device, char* args[]) {
289   uint32_t index = strtoul(args[0], NULL, 0);
290   return device->delete_space(device, index, (uint8_t*)args[3],
291                               strlen(args[3]));
292 }
293 
294 static int HandleDisableCreate(nvram_device_t* device, char* args[]) {
295   (void)args;
296   return device->disable_create(device);
297 }
298 
299 static int HandleWriteSpace(nvram_device_t* device, char* args[]) {
300   uint32_t index = strtoul(args[0], NULL, 0);
301   return device->write_space(device, index, (uint8_t*)args[1], strlen(args[1]),
302                              (uint8_t*)args[2], strlen(args[2]));
303 }
304 
305 static int HandleReadSpace(nvram_device_t* device, char* args[]) {
306   uint32_t index = strtoul(args[0], NULL, 0);
307   uint64_t size = 0;
308   nvram_result_t result = device->get_space_size(device, index, &size);
309   if (result != NV_RESULT_SUCCESS) {
310     return result;
311   }
312 
313   uint8_t* buffer = calloc(sizeof(uint8_t), size);
314   if (!buffer) {
315     return kStatusAllocationFailure;
316   }
317 
318   result = device->read_space(device, index, size, (uint8_t*)args[1],
319                               strlen(args[1]), buffer, &size);
320   if (result != NV_RESULT_SUCCESS) {
321     free(buffer);
322     return result;
323   }
324 
325   fwrite(buffer, sizeof(uint8_t), size, stdout);
326   fputs("\n", stdout);
327   free(buffer);
328   return 0;
329 }
330 
331 static int HandleEnableWriteLock(nvram_device_t* device, char* args[]) {
332   uint32_t index = strtoul(args[0], NULL, 0);
333   return device->enable_write_lock(device, index, (uint8_t*)args[1],
334                                    strlen(args[1]));
335 }
336 
337 static int HandleEnableReadLock(nvram_device_t* device, char* args[]) {
338   uint32_t index = strtoul(args[0], NULL, 0);
339   return device->enable_read_lock(device, index, (uint8_t*)args[1],
340                                   strlen(args[1]));
341 }
342 
343 struct CommandHandler {
344   const char* name;
345   const char* params_desc;
346   int nparams;
347   int (*run)(nvram_device_t*, char* args[]);
348 };
349 
350 struct CommandHandler kCommandHandlers[] = {
351     {"get_total_size", "", 0, &HandleGetTotalSize},
352     {"get_available_size", "", 0, &HandleGetAvailableSize},
353     {"get_max_space_size", "", 0, &HandleGetMaxSpaceSize},
354     {"get_max_spaces", "", 0, &HandleGetMaxSpaces},
355     {"get_space_list", "", 0, &HandleGetSpaceList},
356     {"get_space_size", "<index>", 1, &HandleGetSpaceSize},
357     {"get_space_controls", "<index>", 1, &HandleGetSpaceControls},
358     {"is_space_read_locked", "<index>", 1, &HandleIsSpaceReadLocked},
359     {"is_space_write_locked", "<index>", 1, &HandleIsSpaceWriteLocked},
360     {"create_space", "<index> <size> <controls> <auth>", 4, &HandleCreateSpace},
361     {"delete_space", "<index> <auth>", 2, &HandleDeleteSpace},
362     {"disable_create", "", 0, &HandleDisableCreate},
363     {"write_space", "<index> <data> <auth>", 3, &HandleWriteSpace},
364     {"read_space", "<index> <auth>", 2, &HandleReadSpace},
365     {"enable_write_lock", "<index> <auth>", 2, &HandleEnableWriteLock},
366     {"enable_read_lock", "<index> <auth>", 2, &HandleEnableReadLock},
367 };
368 
369 int main(int argc, char* argv[]) {
370   if (argc < 2) {
371     fprintf(stderr, "Usage: %s <command> <command-args>\n", argv[0]);
372     fprintf(stderr, "Valid commands are:\n");
373     for (size_t i = 0; i < countof(kCommandHandlers); ++i) {
374       fprintf(stderr, "  %s %s\n", kCommandHandlers[i].name,
375               kCommandHandlers[i].params_desc);
376     }
377     return kStatusInvalidArg;
378   }
379 
380   const struct CommandHandler* cmd = NULL;
381   for (size_t i = 0; i < countof(kCommandHandlers); ++i) {
382     if (strcmp(kCommandHandlers[i].name, argv[1]) == 0) {
383       cmd = &kCommandHandlers[i];
384     }
385   }
386 
387   if (!cmd) {
388     fprintf(stderr, "Bad command: %s\n", argv[1]);
389     return kStatusInvalidArg;
390   }
391 
392   if (argc - 2 != cmd->nparams) {
393     fprintf(stderr, "Command %s takes %d parameters, %d given.\n", argv[1],
394             cmd->nparams, argc - 2);
395     return kStatusInvalidArg;
396   }
397 
398   const hw_module_t* module = NULL;
399   nvram_device_t* nvram_device = NULL;
400   if (hw_get_module(NVRAM_HARDWARE_MODULE_ID, &module) != 0 ||
401       module->methods->open(module, NVRAM_HARDWARE_DEVICE_ID,
402                             (hw_device_t**)&nvram_device) != 0) {
403     fprintf(stderr, "Failed to open NVRAM HAL.\n");
404     return kStatusHALError;
405   }
406 
407   if (nvram_device->common.version != NVRAM_DEVICE_API_VERSION_1_1) {
408     fprintf(stderr, "Unsupported NVRAM HAL version.\n");
409     nvram_device->common.close(&nvram_device->common);
410     return kStatusHALError;
411   }
412 
413   int ret = cmd->run(nvram_device, argv + 2);
414   if (ret != 0) {
415     fprintf(stderr, "Command execution failure: %s (%d).\n",
416             StatusToString(ret), ret);
417   }
418 
419   nvram_device->common.close(&nvram_device->common);
420   return ret;
421 }
422