openkylin
/
platform_system_core
mirror of https://gitee.com/openkylin/platform_system_core.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "Clang-format before updating storage proxy"

This commit is contained in:
Treehugger Robot 2019-03-06 00:53:25 +00:00 committed by Gerrit Code Review
parent 925c78b7e8 30ff1f4177
commit 2d85880b49
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 <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <sys/capability.h>
#include <sys/prctl.h>
#include <sys/stat.h>
@ -34,28 +34,24 @@
#define REQ_BUFFER_SIZE 4096
static uint8_t req_buffer[REQ_BUFFER_SIZE + 1];
static const char *ss_data_root;
static const char *trusty_devname;
static const char *rpmb_devname;
static const char *ss_srv_name = STORAGE_DISK_PROXY_PORT;
static const char* ss_data_root;
static const char* trusty_devname;
static const char* rpmb_devname;
static const char* ss_srv_name = STORAGE_DISK_PROXY_PORT;
static const char *_sopts = "hp:d:r:";
static const struct option _lopts[] = {
{"help", no_argument, NULL, 'h'},
{"trusty_dev", required_argument, NULL, 'd'},
{"data_path", required_argument, NULL, 'p'},
{"rpmb_dev", required_argument, NULL, 'r'},
{0, 0, 0, 0}
};
static const char* _sopts = "hp:d:r:";
static const struct option _lopts[] = {{"help", no_argument, NULL, 'h'},
{"trusty_dev", required_argument, NULL, 'd'},
{"data_path", required_argument, NULL, 'p'},
{"rpmb_dev", required_argument, NULL, 'r'},
{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");
exit(code);
}
static int drop_privs(void)
{
static int drop_privs(void) {
struct __user_cap_header_struct capheader;
struct __user_cap_data_struct capdata[2];
@ -95,12 +91,10 @@ static int drop_privs(void)
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;
if ((msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) &&
(msg->cmd != STORAGE_RPMB_SEND)) {
if ((msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) && (msg->cmd != STORAGE_RPMB_SEND)) {
/*
* handling post commit messages on non rpmb commands are not
* 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) {
case STORAGE_FILE_DELETE:
rc = storage_file_delete(msg, req, req_len);
break;
case STORAGE_FILE_DELETE:
rc = storage_file_delete(msg, req, req_len);
break;
case STORAGE_FILE_OPEN:
rc = storage_file_open(msg, req, req_len);
break;
case STORAGE_FILE_OPEN:
rc = storage_file_open(msg, req, req_len);
break;
case STORAGE_FILE_CLOSE:
rc = storage_file_close(msg, req, req_len);
break;
case STORAGE_FILE_CLOSE:
rc = storage_file_close(msg, req, req_len);
break;
case STORAGE_FILE_WRITE:
rc = storage_file_write(msg, req, req_len);
break;
case STORAGE_FILE_WRITE:
rc = storage_file_write(msg, req, req_len);
break;
case STORAGE_FILE_READ:
rc = storage_file_read(msg, req, req_len);
break;
case STORAGE_FILE_READ:
rc = storage_file_read(msg, req, req_len);
break;
case STORAGE_FILE_GET_SIZE:
rc = storage_file_get_size(msg, req, req_len);
break;
case STORAGE_FILE_GET_SIZE:
rc = storage_file_get_size(msg, req, req_len);
break;
case STORAGE_FILE_SET_SIZE:
rc = storage_file_set_size(msg, req, req_len);
break;
case STORAGE_FILE_SET_SIZE:
rc = storage_file_set_size(msg, req, req_len);
break;
case STORAGE_RPMB_SEND:
rc = rpmb_send(msg, req, req_len);
break;
case STORAGE_RPMB_SEND:
rc = rpmb_send(msg, req, req_len);
break;
default:
ALOGE("unhandled command 0x%x\n", msg->cmd);
msg->result = STORAGE_ERR_UNIMPLEMENTED;
rc = 1;
default:
ALOGE("unhandled command 0x%x\n", msg->cmd);
msg->result = STORAGE_ERR_UNIMPLEMENTED;
rc = 1;
}
if (rc > 0) {
@ -164,58 +158,50 @@ static int handle_req(struct storage_msg *msg, const void *req, size_t req_len)
return rc;
}
static int proxy_loop(void)
{
static int proxy_loop(void) {
ssize_t rc;
struct storage_msg msg;
/* enter main message handling loop */
while (true) {
/* get incoming message */
rc = ipc_get_msg(&msg, req_buffer, REQ_BUFFER_SIZE);
if (rc < 0)
return rc;
if (rc < 0) return rc;
/* handle request */
req_buffer[rc] = 0; /* force zero termination */
rc = handle_req(&msg, req_buffer, rc);
if (rc)
return rc;
if (rc) return rc;
}
return 0;
}
static void parse_args(int argc, char *argv[])
{
static void parse_args(int argc, char* argv[]) {
int opt;
int oidx = 0;
while ((opt = getopt_long(argc, argv, _sopts, _lopts, &oidx)) != -1) {
switch (opt) {
case 'd':
trusty_devname = strdup(optarg);
break;
case 'd':
trusty_devname = strdup(optarg);
break;
case 'p':
ss_data_root = strdup(optarg);
break;
case 'p':
ss_data_root = strdup(optarg);
break;
case 'r':
rpmb_devname = strdup(optarg);
break;
case 'r':
rpmb_devname = strdup(optarg);
break;
default:
ALOGE("unrecognized option (%c):\n", opt);
show_usage_and_exit(EXIT_FAILURE);
default:
ALOGE("unrecognized option (%c):\n", opt);
show_usage_and_exit(EXIT_FAILURE);
}
}
if (ss_data_root == NULL ||
trusty_devname == NULL ||
rpmb_devname == NULL) {
if (ss_data_root == NULL || trusty_devname == NULL || rpmb_devname == NULL) {
ALOGE("missing required argument(s)\n");
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);
}
int main(int argc, char *argv[])
{
int main(int argc, char* argv[]) {
int rc;
/* drop privileges */
if (drop_privs() < 0)
return EXIT_FAILURE;
if (drop_privs() < 0) return EXIT_FAILURE;
/* parse arguments */
parse_args(argc, argv);
/* initialize secure storage directory */
rc = storage_init(ss_data_root);
if (rc < 0)
return EXIT_FAILURE;
if (rc < 0) return EXIT_FAILURE;
/* open rpmb device */
rc = rpmb_open(rpmb_devname);
if (rc < 0)
return EXIT_FAILURE;
if (rc < 0) return EXIT_FAILURE;
/* connect to Trusty secure storage server */
rc = ipc_connect(trusty_devname, ss_srv_name);
if (rc < 0)
return EXIT_FAILURE;
if (rc < 0) return EXIT_FAILURE;
/* enter main 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
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;
printf("%s @%p [%zu]", prefix, buf, size);
for (i = 0; i < size; i++) {
if (i && i % 32 == 0)
printf("\n%*s", (int) strlen(prefix), "");
if (i && i % 32 == 0) printf("\n%*s", (int)strlen(prefix), "");
printf(" %02x", buf[i]);
}
printf("\n");
@ -70,34 +68,29 @@ static void print_buf(const char *prefix, const uint8_t *buf, size_t size)
#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;
struct {
struct mmc_ioc_multi_cmd multi;
struct mmc_ioc_cmd cmd_buf[3];
} mmc = {};
struct mmc_ioc_cmd *cmd = mmc.multi.cmds;
const struct storage_rpmb_send_req *req = r;
struct mmc_ioc_cmd* cmd = mmc.multi.cmds;
const struct storage_rpmb_send_req* req = r;
if (req_len < sizeof(*req)) {
ALOGW("malformed rpmb request: invalid length (%zu < %zu)\n",
req_len, sizeof(*req));
ALOGW("malformed rpmb request: invalid length (%zu < %zu)\n", req_len, sizeof(*req));
msg->result = STORAGE_ERR_NOT_VALID;
goto err_response;
}
size_t expected_len =
sizeof(*req) + req->reliable_write_size + req->write_size;
size_t expected_len = sizeof(*req) + req->reliable_write_size + req->write_size;
if (req_len != expected_len) {
ALOGW("malformed rpmb request: invalid length (%zu != %zu)\n",
req_len, expected_len);
ALOGW("malformed rpmb request: invalid length (%zu != %zu)\n", req_len, expected_len);
msg->result = STORAGE_ERR_NOT_VALID;
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 % MMC_BLOCK_SIZE) != 0) {
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 % MMC_BLOCK_SIZE != 0 ||
req->read_size > sizeof(read_buf)) {
if (req->read_size % MMC_BLOCK_SIZE != 0 || req->read_size > sizeof(read_buf)) {
ALOGE("%s: invalid read size %u\n", __func__, req->read_size);
msg->result = STORAGE_ERR_NOT_VALID;
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->opcode = MMC_READ_MULTIPLE_BLOCK;
cmd->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC,
cmd->blksz = MMC_BLOCK_SIZE;
cmd->flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC, cmd->blksz = MMC_BLOCK_SIZE;
cmd->blocks = req->read_size / MMC_BLOCK_SIZE;
mmc_ioc_cmd_set_data((*cmd), read_buf);
#ifdef RPMB_DEBUG
@ -170,8 +161,7 @@ int rpmb_send(struct storage_msg *msg, const void *r, size_t req_len)
goto err_response;
}
#ifdef RPMB_DEBUG
if (req->read_size)
print_buf("response: ", read_buf, req->read_size);
if (req->read_size) print_buf("response: ", read_buf, req->read_size);
#endif
if (msg->flags & STORAGE_MSG_FLAG_POST_COMMIT) {
@ -188,24 +178,19 @@ err_response:
return ipc_respond(msg, NULL, 0);
}
int rpmb_open(const char *rpmb_devname)
{
int rpmb_open(const char* rpmb_devname) {
int rc;
rc = open(rpmb_devname, O_RDWR, 0);
if (rc < 0) {
ALOGE("unable (%d) to open rpmb device '%s': %s\n",
errno, rpmb_devname, strerror(errno));
ALOGE("unable (%d) to open rpmb device '%s': %s\n", errno, rpmb_devname, strerror(errno));
return rc;
}
rpmb_fd = rc;
return 0;
}
void rpmb_close(void)
{
void rpmb_close(void) {
close(rpmb_fd);
rpmb_fd = -1;
}

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

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