ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Clang-format before updating storage proxy"

Browse source 
am: 2d85880b49

Change-Id: I4326644ebc3f14c72c97c9fdb279026d97aee0ac
This commit is contained in:
Matthew Maurer 2019-03-05 17:25:11 -08:00 • committed by android-build-merger
commit 71e96ea355
3 changed files with 82 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
trusty/storage/proxy/proxy.c
View file

@ -17,8 +17,8 @@
#include <getopt.h> #include <getopt.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <sys/capability.h> #include <sys/capability.h>
#include <sys/prctl.h> #include <sys/prctl.h>
#include <sys/stat.h> #include <sys/stat.h>
@ -34,28 +34,24 @@
#define REQ_BUFFER_SIZE 4096 #define REQ_BUFFER_SIZE 4096
static uint8_t req_buffer[REQ_BUFFER_SIZE + 1]; static uint8_t req_buffer[REQ_BUFFER_SIZE + 1];
static const char *ss_data_root; static const char* ss_data_root;
static const char *trusty_devname; static const char* trusty_devname;
static const char *rpmb_devname; static const char* rpmb_devname;
static const char *ss_srv_name = STORAGE_DISK_PROXY_PORT; static const char* ss_srv_name = STORAGE_DISK_PROXY_PORT;
static const char *_sopts = "hp:d:r:"; static const char* _sopts = "hp:d:r:";
static const struct option _lopts[] = { static const struct option _lopts[] = {{"help", no_argument, NULL, 'h'},
{"help", no_argument, NULL, 'h'}, {"trusty_dev", required_argument, NULL, 'd'},
{"trusty_dev", required_argument, NULL, 'd'}, {"data_path", required_argument, NULL, 'p'},
{"data_path", required_argument, NULL, 'p'}, {"rpmb_dev", required_argument, NULL, 'r'},
{"rpmb_dev", required_argument, NULL, 'r'}, {0, 0, 0, 0}};
{0, 0, 0, 0}
};
static void show_usage_and_exit(int code) static void show_usage_and_exit(int code) {
{
ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev>\n"); ALOGE("usage: storageproxyd -d <trusty_dev> -p <data_path> -r <rpmb_dev>\n");
exit(code); exit(code);
} }
static int drop_privs(void) static int drop_privs(void) {
{
struct __user_cap_header_struct capheader; struct __user_cap_header_struct capheader;
struct __user_cap_data_struct capdata[2]; struct __user_cap_data_struct capdata[2];
@ -95,12 +91,10 @@ static int drop_privs(void)
return 0; return 0;
} }
static int handle_req(struct storage_msg *msg, const void *req, size_t req_len) static int handle_req(struct storage_msg* msg, const void* req, size_t req_len) {
{
int rc; int rc;
if ((msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) && if ((msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) && (msg->cmd != STORAGE_RPMB_SEND)) {
(msg->cmd != STORAGE_RPMB_SEND)) {
/* /*
* handling post commit messages on non rpmb commands are not * handling post commit messages on non rpmb commands are not
* implemented as there is no use case for this yet. * implemented as there is no use case for this yet.
@ -119,42 +113,42 @@ static int handle_req(struct storage_msg *msg, const void *req, size_t req_len)
} }
switch (msg->cmd) { switch (msg->cmd) {
case STORAGE_FILE_DELETE: case STORAGE_FILE_DELETE:
rc = storage_file_delete(msg, req, req_len); rc = storage_file_delete(msg, req, req_len);
break; break;
case STORAGE_FILE_OPEN: case STORAGE_FILE_OPEN:
rc = storage_file_open(msg, req, req_len); rc = storage_file_open(msg, req, req_len);
break; break;
case STORAGE_FILE_CLOSE: case STORAGE_FILE_CLOSE:
rc = storage_file_close(msg, req, req_len); rc = storage_file_close(msg, req, req_len);
break; break;
case STORAGE_FILE_WRITE: case STORAGE_FILE_WRITE:
rc = storage_file_write(msg, req, req_len); rc = storage_file_write(msg, req, req_len);
break; break;
case STORAGE_FILE_READ: case STORAGE_FILE_READ:
rc = storage_file_read(msg, req, req_len); rc = storage_file_read(msg, req, req_len);
break; break;
case STORAGE_FILE_GET_SIZE: case STORAGE_FILE_GET_SIZE:
rc = storage_file_get_size(msg, req, req_len); rc = storage_file_get_size(msg, req, req_len);
break; break;
case STORAGE_FILE_SET_SIZE: case STORAGE_FILE_SET_SIZE:
rc = storage_file_set_size(msg, req, req_len); rc = storage_file_set_size(msg, req, req_len);
break; break;
case STORAGE_RPMB_SEND: case STORAGE_RPMB_SEND:
rc = rpmb_send(msg, req, req_len); rc = rpmb_send(msg, req, req_len);
break; break;
default: default:
ALOGE("unhandled command 0x%x\n", msg->cmd); ALOGE("unhandled command 0x%x\n", msg->cmd);
msg->result = STORAGE_ERR_UNIMPLEMENTED; msg->result = STORAGE_ERR_UNIMPLEMENTED;
rc = 1; rc = 1;
} }
if (rc > 0) { if (rc > 0) {
@ -164,58 +158,50 @@ static int handle_req(struct storage_msg *msg, const void *req, size_t req_len)
return rc; return rc;
} }
static int proxy_loop(void) static int proxy_loop(void) {
{
ssize_t rc; ssize_t rc;
struct storage_msg msg; struct storage_msg msg;
/* enter main message handling loop */ /* enter main message handling loop */
while (true) { while (true) {
/* get incoming message */ /* get incoming message */
rc = ipc_get_msg(&msg, req_buffer, REQ_BUFFER_SIZE); rc = ipc_get_msg(&msg, req_buffer, REQ_BUFFER_SIZE);
if (rc < 0) if (rc < 0) return rc;
return rc;
/* handle request */ /* handle request */
req_buffer[rc] = 0; /* force zero termination */ req_buffer[rc] = 0; /* force zero termination */
rc = handle_req(&msg, req_buffer, rc); rc = handle_req(&msg, req_buffer, rc);
if (rc) if (rc) return rc;
return rc;
} }
return 0; return 0;
} }
static void parse_args(int argc, char *argv[]) static void parse_args(int argc, char* argv[]) {
{
int opt; int opt;
int oidx = 0; int oidx = 0;
while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) { while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) {
switch (opt) { switch (opt) {
case 'd':
trusty_devname = strdup(optarg);
break;
case 'd': case 'p':
trusty_devname = strdup(optarg); ss_data_root = strdup(optarg);
break; break;
case 'p': case 'r':
ss_data_root = strdup(optarg); rpmb_devname = strdup(optarg);
break; break;
case 'r': default:
rpmb_devname = strdup(optarg); ALOGE("unrecognized option (%c):\n", opt);
break; show_usage_and_exit(EXIT_FAILURE);
default:
ALOGE("unrecognized option (%c):\n", opt);
show_usage_and_exit(EXIT_FAILURE);
} }
} }
if (ss_data_root == NULL || if (ss_data_root == NULL || trusty_devname == NULL || rpmb_devname == NULL) {
trusty_devname == NULL ||
rpmb_devname == NULL) {
ALOGE("missing required argument(s)\n"); ALOGE("missing required argument(s)\n");
show_usage_and_exit(EXIT_FAILURE); show_usage_and_exit(EXIT_FAILURE);
} }
@ -226,31 +212,26 @@ static void parse_args(int argc, char *argv[])
ALOGI("rpmb dev: %s\n", rpmb_devname); ALOGI("rpmb dev: %s\n", rpmb_devname);
} }
int main(int argc, char *argv[]) int main(int argc, char* argv[]) {
{
int rc; int rc;
/* drop privileges */ /* drop privileges */
if (drop_privs() < 0) if (drop_privs() < 0) return EXIT_FAILURE;
return EXIT_FAILURE;
/* parse arguments */ /* parse arguments */
parse_args(argc, argv); parse_args(argc, argv);
/* initialize secure storage directory */ /* initialize secure storage directory */
rc = storage_init(ss_data_root); rc = storage_init(ss_data_root);
if (rc < 0) if (rc < 0) return EXIT_FAILURE;
return EXIT_FAILURE;
/* open rpmb device */ /* open rpmb device */
rc = rpmb_open(rpmb_devname); rc = rpmb_open(rpmb_devname);
if (rc < 0) if (rc < 0) return EXIT_FAILURE;
return EXIT_FAILURE;
/* connect to Trusty secure storage server */ /* connect to Trusty secure storage server */
rc = ipc_connect(trusty_devname, ss_srv_name); rc = ipc_connect(trusty_devname, ss_srv_name);
if (rc < 0) if (rc < 0) return EXIT_FAILURE;
return EXIT_FAILURE;
/* enter main loop */ /* enter main loop */
rc = proxy_loop(); rc = proxy_loop();

45
trusty/storage/proxy/rpmb.c
View file

@ -54,14 +54,12 @@ static uint8_t read_buf[4096];
#ifdef RPMB_DEBUG #ifdef RPMB_DEBUG
static void print_buf(const char *prefix, const uint8_t *buf, size_t size) static void print_buf(const char* prefix, const uint8_t* buf, size_t size) {
{
size_t i; size_t i;
printf("%s @%p [%zu]", prefix, buf, size); printf("%s @%p [%zu]", prefix, buf, size);
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
if (i && i % 32 == 0) if (i && i % 32 == 0) printf("\n%*s", (int)strlen(prefix), "");
printf("\n%*s", (int) strlen(prefix), "");
printf(" %02x", buf[i]); printf(" %02x", buf[i]);
} }
printf("\n"); printf("\n");
@ -70,34 +68,29 @@ static void print_buf(const char *prefix, const uint8_t *buf, size_t size)
#endif #endif
int rpmb_send(struct storage_msg* msg, const void* r, size_t req_len) {
int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len)
{
int rc; int rc;
struct { struct {
struct mmc_ioc_multi_cmd multi; struct mmc_ioc_multi_cmd multi;
struct mmc_ioc_cmd cmd_buf[3]; struct mmc_ioc_cmd cmd_buf[3];
} mmc = {}; } mmc = {};
struct mmc_ioc_cmd *cmd = mmc.multi.cmds; struct mmc_ioc_cmd* cmd = mmc.multi.cmds;
const struct storage_rpmb_send_req *req = r; const struct storage_rpmb_send_req* req = r;
if (req_len < sizeof(*req)) { if (req_len < sizeof(*req)) {
ALOGW("malformed rpmb request: invalid length (%zu < %zu)\n", ALOGW("malformed rpmb request: invalid length (%zu < %zu)\n", req_len, sizeof(*req));
req_len, sizeof(*req));
msg->result = STORAGE_ERR_NOT_VALID; msg->result = STORAGE_ERR_NOT_VALID;
goto err_response; goto err_response;
} }
size_t expected_len = size_t expected_len = sizeof(*req) + req->reliable_write_size + req->write_size;
sizeof(*req) + req->reliable_write_size + req->write_size;
if (req_len != expected_len) { if (req_len != expected_len) {
ALOGW("malformed rpmb request: invalid length (%zu != %zu)\n", ALOGW("malformed rpmb request: invalid length (%zu != %zu)\n", req_len, expected_len);
req_len, expected_len);
msg->result = STORAGE_ERR_NOT_VALID; msg->result = STORAGE_ERR_NOT_VALID;
goto err_response; goto err_response;
} }
const uint8_t *write_buf = req->payload; const uint8_t* write_buf = req->payload;
if (req->reliable_write_size) { if (req->reliable_write_size) {
if ((req->reliable_write_size % MMC_BLOCK_SIZE) != 0) { if ((req->reliable_write_size % MMC_BLOCK_SIZE) != 0) {
ALOGW("invalid reliable write size %u\n", req->reliable_write_size); ALOGW("invalid reliable write size %u\n", req->reliable_write_size);
@ -143,8 +136,7 @@ int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len)
} }
if (req->read_size) { if (req->read_size) {
if (req->read_size % MMC_BLOCK_SIZE != 0 || if (req->read_size % MMC_BLOCK_SIZE != 0 || req->read_size > sizeof(read_buf)) {
req->read_size > sizeof(read_buf)) {
ALOGE("%s: invalid read size %u\n", __func__, req->read_size); ALOGE("%s: invalid read size %u\n", __func__, req->read_size);
msg->result = STORAGE_ERR_NOT_VALID; msg->result = STORAGE_ERR_NOT_VALID;
goto err_response; goto err_response;
@ -152,8 +144,7 @@ int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len)
cmd->write_flag = MMC_WRITE_FLAG_R; cmd->write_flag = MMC_WRITE_FLAG_R;
cmd->opcode = MMC_READ_MULTIPLE_BLOCK; cmd->opcode = MMC_READ_MULTIPLE_BLOCK;
cmd->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC, cmd->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC, cmd->blksz = MMC_BLOCK_SIZE;
cmd->blksz = MMC_BLOCK_SIZE;
cmd->blocks = req->read_size / MMC_BLOCK_SIZE; cmd->blocks = req->read_size / MMC_BLOCK_SIZE;
mmc_ioc_cmd_set_data((*cmd), read_buf); mmc_ioc_cmd_set_data((*cmd), read_buf);
#ifdef RPMB_DEBUG #ifdef RPMB_DEBUG
@ -170,8 +161,7 @@ int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len)
goto err_response; goto err_response;
} }
#ifdef RPMB_DEBUG #ifdef RPMB_DEBUG
if (req->read_size) if (req->read_size) print_buf("response: ", read_buf, req->read_size);
print_buf("response: ", read_buf, req->read_size);
#endif #endif
if (msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) { if (msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) {
@ -188,24 +178,19 @@ err_response:
return ipc_respond(msg, NULL, 0); return ipc_respond(msg, NULL, 0);
} }
int rpmb_open(const char* rpmb_devname) {
int rpmb_open(const char *rpmb_devname)
{
int rc; int rc;
rc = open(rpmb_devname, O_RDWR, 0); rc = open(rpmb_devname, O_RDWR, 0);
if (rc < 0) { if (rc < 0) {
ALOGE("unable (%d) to open rpmb device '%s': %s\n", ALOGE("unable (%d) to open rpmb device '%s': %s\n", errno, rpmb_devname, strerror(errno));
errno, rpmb_devname, strerror(errno));
return rc; return rc;
} }
rpmb_fd = rc; rpmb_fd = rc;
return 0; return 0;
} }
void rpmb_close(void) void rpmb_close(void) {
{
close(rpmb_fd); close(rpmb_fd);
rpmb_fd = -1; rpmb_fd = -1;
} }

4
trusty/storage/proxy/rpmb.h
View file

@ -18,6 +18,6 @@
#include <stdint.h> #include <stdint.h>
#include <trusty/interface/storage.h> #include <trusty/interface/storage.h>
int rpmb_open(const char *rpmb_devname); int rpmb_open(const char* rpmb_devname);
int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len); int rpmb_send(struct storage_msg* msg, const void* r, size_t req_len);
void rpmb_close(void); void rpmb_close(void);