static int
test_block_manager ()
{
SeafBlockManager *mgr = seaf->block_mgr;
char *block_id = "c882e263e9d02c63ca6b61c68508761cbc74c358";
char wr_buf[1024], rd_buf[1024];
BlockHandle *handle;
BlockMetadata *md;
int n;
printf ("\n=== Test block manager\n\n");
memset (wr_buf, 1, sizeof(wr_buf));
handle = seaf_block_manager_open_block (mgr, block_id, BLOCK_WRITE);
g_assert (handle != NULL);
n = seaf_block_manager_write_block (mgr, handle, wr_buf, sizeof(wr_buf));
g_assert (n == sizeof(wr_buf));
md = seaf_block_manager_stat_block_by_handle (mgr, handle);
g_assert (md->size == sizeof(wr_buf));
g_free (md);
g_assert (seaf_block_manager_close_block(mgr, handle) == 0);
g_assert (seaf_block_manager_commit_block(mgr, handle) == 0);
seaf_block_manager_block_handle_free (mgr, handle);
handle = seaf_block_manager_open_block (mgr, block_id, BLOCK_READ);
g_assert (handle != NULL);
n = seaf_block_manager_read_block (mgr, handle, rd_buf, sizeof(rd_buf));
g_assert (n == sizeof(rd_buf));
md = seaf_block_manager_stat_block_by_handle (mgr, handle);
g_assert (md->size == sizeof(wr_buf));
g_free (md);
g_assert (seaf_block_manager_close_block(mgr, handle) == 0);
seaf_block_manager_block_handle_free (mgr, handle);
g_assert (memcmp (wr_buf, rd_buf, sizeof(wr_buf)) == 0);
md = seaf_block_manager_stat_block (mgr, block_id);
g_assert (strcmp (md->id, block_id) == 0);
g_assert (md->size == sizeof(wr_buf));
g_free (md);
return 0;
}
gboolean
seaf_block_manager_verify_block (SeafBlockManager *mgr,
const char *store_id,
int version,
const char *block_id,
gboolean *io_error)
{
BlockHandle *h;
char buf[10240];
int n;
SHA_CTX ctx;
guint8 sha1[20];
char check_id[41];
h = seaf_block_manager_open_block (mgr,
store_id, version,
block_id, BLOCK_READ);
if (!h) {
seaf_warning ("Failed to open block %.8s.\n", block_id);
*io_error = TRUE;
return FALSE;
}
SHA1_Init (&ctx);
while (1) {
n = seaf_block_manager_read_block (mgr, h, buf, sizeof(buf));
if (n < 0) {
seaf_warning ("Failed to read block %.8s.\n", block_id);
*io_error = TRUE;
return FALSE;
}
if (n == 0)
break;
SHA1_Update (&ctx, buf, n);
}
seaf_block_manager_close_block (mgr, h);
seaf_block_manager_block_handle_free (mgr, h);
SHA1_Final (sha1, &ctx);
rawdata_to_hex (sha1, check_id, 20);
if (strcmp (check_id, block_id) == 0)
return TRUE;
else
return FALSE;
}
static gboolean
write_nonenc_block_to_file (const char *repo_id,
int version,
const char *block_id,
int fd,
const char *path)
{
BlockHandle *handle;
char buf[64 * 1024];
gboolean ret = TRUE;
int n;
handle = seaf_block_manager_open_block (seaf->block_mgr,
repo_id, version,
block_id, BLOCK_READ);
if (!handle) {
return FALSE;
}
while (1) {
n = seaf_block_manager_read_block (seaf->block_mgr, handle, buf, sizeof(buf));
if (n < 0) {
seaf_warning ("Failed to read block %s.\n", block_id);
ret = FALSE;
break;
} else if (n == 0) {
break;
}
if (writen (fd, buf, n) != n) {
seaf_warning ("Failed to write block %s to file %s.\n",
block_id, path);
ret = FALSE;
break;
}
}
seaf_block_manager_close_block (seaf->block_mgr, handle);
seaf_block_manager_block_handle_free (seaf->block_mgr, handle);
return ret;
}
static int
send_block_content (BlockTxServer *server, int block_size)
{
BlockHandle *handle = NULL;
int ret = 0;
handle = seaf_block_manager_open_block (seaf->block_mgr,
server->store_id,
server->repo_version,
server->curr_block_id,
BLOCK_READ);
if (!handle) {
seaf_warning ("Failed to open block %s.\n", server->curr_block_id);
return -1;
}
ret = send_encrypted_block (server, handle, server->curr_block_id, block_size);
seaf_block_manager_close_block (seaf->block_mgr, handle);
seaf_block_manager_block_handle_free (seaf->block_mgr, handle);
return ret;
}
static int
send_block_content (BlockTxClient *client)
{
TransferTask *task = client->info->task;
BlockHandle *handle = NULL;
int ret = 0;
handle = seaf_block_manager_open_block (seaf->block_mgr,
task->repo_id,
task->repo_version,
client->curr_block_id,
BLOCK_READ);
if (!handle) {
seaf_warning ("Failed to open block %s.\n", client->curr_block_id);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
}
ret = send_encrypted_block (client, handle, client->curr_block_id);
seaf_block_manager_close_block (seaf->block_mgr, handle);
seaf_block_manager_block_handle_free (seaf->block_mgr, handle);
return ret;
}
static int
handle_block_header_content_cb (char *content, int clen, void *cbarg)
{
BlockTxClient *client = cbarg;
ResponseHeader *hdr;
TransferTask *task = client->info->task;
if (clen != sizeof(ResponseHeader)) {
seaf_warning ("Invalid block response header length %d.\n", clen);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
}
hdr = (ResponseHeader *)content;
hdr->status = ntohl (hdr->status);
if (task->type == TASK_TYPE_UPLOAD) {
switch (hdr->status) {
case STATUS_OK:
seaf_debug ("Put block %s succeeded.\n", client->curr_block_id);
if (transfer_next_block (client) < 0)
return -1;
return 0;
case STATUS_INTERNAL_SERVER_ERROR:
client->info->result = BLOCK_CLIENT_SERVER_ERROR;
return -1;
default:
seaf_warning ("Unexpected response: %d.\n", hdr->status);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
}
} else {
switch (hdr->status) {
case STATUS_OK:
client->block = seaf_block_manager_open_block (seaf->block_mgr,
task->repo_id,
task->repo_version,
client->curr_block_id,
BLOCK_WRITE);
if (!client->block) {
seaf_warning ("Failed to open block %s for write.\n",
client->curr_block_id);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
}
seaf_debug ("recv_state set to CONTENT.\n");
client->recv_state = RECV_STATE_CONTENT;
return 0;
case STATUS_INTERNAL_SERVER_ERROR:
client->info->result = BLOCK_CLIENT_SERVER_ERROR;
return -1;
case STATUS_NOT_FOUND:
seaf_warning ("Block %s is not found on server.\n",
client->curr_block_id);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
default:
seaf_warning ("Unexpected response: %d.\n", hdr->status);
client->info->result = BLOCK_CLIENT_FAILED;
return -1;
}
}
}
int read_file(SeafileSession *seaf, Seafile *file, char *buf, size_t size,
off_t offset, struct fuse_file_info *info)
{
BlockHandle *handle = NULL;;
BlockMetadata *bmd;
char *blkid;
char *ptr;
off_t off = 0, nleft;
int i, n, ret = -EIO;
for (i = 0; i < file->n_blocks; i++) {
blkid = file->blk_sha1s[i];
bmd = seaf_block_manager_stat_block(seaf->block_mgr, blkid);
if (!bmd)
return -EIO;
if (offset < off + bmd->size) {
g_free (bmd);
break;
}
off += bmd->size;
g_free (bmd);
}
/* beyond the file size */
if (i == file->n_blocks)
return 0;
nleft = size;
ptr = buf;
while (nleft > 0 && i < file->n_blocks) {
blkid = file->blk_sha1s[i];
handle = seaf_block_manager_open_block(seaf->block_mgr, blkid, BLOCK_READ);
if (!handle) {
seaf_warning ("Failed to open block %s.\n", blkid);
return -EIO;
}
/* trim the offset in a block */
if (offset > off) {
char *tmp = (char *)malloc(sizeof(char) * (offset - off));
if (!tmp)
return -ENOMEM;
n = seaf_block_manager_read_block(seaf->block_mgr, handle,
tmp, offset-off);
if (n != offset - off) {
seaf_warning ("Failed to read block %s.\n", blkid);
free (tmp);
goto out;
}
off += n;
free(tmp);
}
if ((n = seaf_block_manager_read_block(seaf->block_mgr,
handle, ptr, nleft)) < 0) {
seaf_warning ("Failed to read block %s.\n", blkid);
goto out;
}
nleft -= n;
ptr += n;
off += n;
++i;
/* At this point we should have read all the content of the block or
* have read up to @size bytes. So it's safe to close the block.
*/
seaf_block_manager_close_block(seaf->block_mgr, handle);
seaf_block_manager_block_handle_free (seaf->block_mgr, handle);
}
return size - nleft;
out:
if (handle) {
seaf_block_manager_close_block(seaf->block_mgr, handle);
seaf_block_manager_block_handle_free (seaf->block_mgr, handle);
}
return ret;
}
static int
handle_block_header_content_cb (char *content, int clen, void *cbarg)
{
BlockTxServer *server = cbarg;
RequestHeader *hdr;
if (clen != sizeof(RequestHeader)) {
seaf_warning ("Invalid block request header length %d.\n", clen);
send_block_response_header (server, STATUS_BAD_REQUEST);
return -1;
}
hdr = (RequestHeader *)content;
hdr->command = ntohl (hdr->command);
if (hdr->command != REQUEST_COMMAND_GET &&
hdr->command != REQUEST_COMMAND_PUT) {
seaf_warning ("Unknow command %d.\n", hdr->command);
send_block_response_header (server, STATUS_BAD_REQUEST);
return -1;
}
server->command = hdr->command;
memcpy (server->curr_block_id, hdr->block_id, 40);
if (server->command == REQUEST_COMMAND_GET) {
BlockMetadata *md;
int block_size;
seaf_debug ("Received GET request for block %s.\n", server->curr_block_id);
md = seaf_block_manager_stat_block (seaf->block_mgr,
server->store_id,
server->repo_version,
server->curr_block_id);
if (!md) {
seaf_warning ("Failed to stat block %s.\n", server->curr_block_id);
send_block_response_header (server, STATUS_NOT_FOUND);
return -1;
}
block_size = md->size;
g_free (md);
if (send_block_response_header (server, STATUS_OK) < 0)
return -1;
if (send_block_content (server, block_size) < 0)
return -1;
seaf_debug ("recv_state set to HEADER.\n");
server->recv_state = RECV_STATE_HEADER;
} else {
seaf_debug ("Received PUT request for block %s.\n", server->curr_block_id);
server->block = seaf_block_manager_open_block (seaf->block_mgr,
server->store_id,
server->repo_version,
server->curr_block_id,
BLOCK_WRITE);
if (!server->block) {
seaf_warning ("Failed to open block %s for write.\n",
server->curr_block_id);
send_block_response_header (server, STATUS_INTERNAL_SERVER_ERROR);
return -1;
}
seaf_debug ("recv_state set to CONTENT.\n");
server->parser.fragment_cb = save_block_content_cb;
server->recv_state = RECV_STATE_CONTENT;
}
return 0;
}
