static int handle_ufi_command(struct sandbox_flash_plat *plat,
struct sandbox_flash_priv *priv, const void *buff,
int len)
{
const struct scsi_cmd *req = buff;
switch (*req->cmd) {
case SCSI_INQUIRY: {
struct scsi_inquiry_resp *resp = (void *)priv->buff;
priv->alloc_len = req->cmd[4];
memset(resp, '\0', sizeof(*resp));
resp->data_format = 1;
resp->additional_len = 0x1f;
strncpy(resp->vendor,
plat->flash_strings[STRINGID_MANUFACTURER - 1].s,
sizeof(resp->vendor));
strncpy(resp->product,
plat->flash_strings[STRINGID_PRODUCT - 1].s,
sizeof(resp->product));
strncpy(resp->revision, "1.0", sizeof(resp->revision));
setup_response(priv, resp, sizeof(*resp));
break;
}
case SCSI_TST_U_RDY:
setup_response(priv, NULL, 0);
break;
case SCSI_RD_CAPAC: {
struct scsi_read_capacity_resp *resp = (void *)priv->buff;
uint blocks;
if (priv->file_size)
blocks = priv->file_size / SANDBOX_FLASH_BLOCK_LEN - 1;
else
blocks = 0;
resp->last_block_addr = cpu_to_be32(blocks);
resp->block_len = cpu_to_be32(SANDBOX_FLASH_BLOCK_LEN);
setup_response(priv, resp, sizeof(*resp));
break;
}
case SCSI_READ10: {
struct scsi_read10_req *req = (void *)buff;
handle_read(priv, be32_to_cpu(req->lba),
be16_to_cpu(req->transfer_len));
break;
}
default:
debug("Command not supported: %x\n", req->cmd[0]);
return -EPROTONOSUPPORT;
}
priv->phase = priv->transfer_len ? PHASE_DATA : PHASE_STATUS;
return 0;
}
// returns 1 on successful parsing, 0 on parsing incomplete, -1 on connection close
static int read_request(struct cs_io *cs_w) {
const char *method, *path;
int minor_version;
struct phr_header headers[100];
size_t method_len, path_len, num_headers;
int pret;
ssize_t rret;
/* read the request */
rret = recv(cs_w->io.fd, cs_w->buf + cs_w->len, sizeof cs_w->buf - cs_w->len, MSG_DONTWAIT);
if (rret < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK)
return 0;
die("recv");
}
if (rret == 0) {
fprintf(stderr, "connection closed by peer, len = %d\n", sizeof cs_w->buf - cs_w->len);
fflush(stderr);
return -1;
}
cs_w->last_len = cs_w->len;
cs_w->len += rret;
num_headers = sizeof headers / sizeof headers[0];
/* parse the request */
pret = phr_parse_request(
cs_w->buf,
cs_w->len,
&method,
&method_len,
&path,
&path_len,
&minor_version,
headers,
&num_headers,
cs_w->last_len
);
// puts("finished parsing");
if (pret > 0) {
/* successfully parsed the request */
cs_w->len = pret;
setup_response(cs_w);
// printf("response was setup: %d\n", cs_w->response_len);
return 1;
}
if (pret == -1) {
puts("parse error");
exit(EXIT_FAILURE);
}
/* request is incomplete, continue the loop */
assert(pret == -2);
if (cs_w->len == sizeof cs_w->buf) {
puts("request is too long");
exit(EXIT_FAILURE);
}
return 0;
}
static
int message_complete_callback(http_parser *parser)
{
http_connection *http = PARSER_TO_CONNECTION(parser);
http->message_complete = 1;
// rope_puts(&http->data);
setup_response(http);
return 0;
}
static void handle_read(struct sandbox_flash_priv *priv, ulong lba,
ulong transfer_len)
{
debug("%s: lba=%lx, transfer_len=%lx\n", __func__, lba, transfer_len);
if (priv->fd != -1) {
os_lseek(priv->fd, lba * SANDBOX_FLASH_BLOCK_LEN, OS_SEEK_SET);
priv->read_len = transfer_len;
setup_response(priv, priv->buff,
transfer_len * SANDBOX_FLASH_BLOCK_LEN);
} else {
setup_fail_response(priv);
}
}
