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; }