static void receive_commit (CcnetProcessor *processor, char *content, int clen) { USE_PRIV; ObjectPack *pack = (ObjectPack *)content; if (clen < sizeof(ObjectPack)) { g_warning ("[getcommit] invalid object id.\n"); goto bad; } g_debug ("[getcommit] recv commit object %s\n", pack->id); --priv->pending_objects; if (save_commit (pack, clen) < 0) { goto bad; } if (priv->pending_objects == 0) { g_debug ("[getcommit] Receive commit completed.\n"); ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0); ccnet_processor_done (processor, TRUE); } return; bad: ccnet_processor_send_update (processor, SC_BAD_OBJECT, SS_BAD_OBJECT, NULL, 0); g_warning ("[getcommit] Bad commit object received.\n"); transfer_task_set_error (((SeafileGetcommitProc *)processor)->tx_task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_done (processor, FALSE); }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendcommitV3Proc *proc = (SeafileSendcommitV3Proc *)processor; TransferTask *task = proc->tx_task; if (task->state != TASK_STATE_NORMAL) { ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (memcmp (code, SC_OK, 3) == 0) { processor->state = SEND_OBJECT; send_commits (processor, task->head); } else { g_warning ("Bad response: %s %s.\n", code, code_msg); ccnet_processor_done (processor, FALSE); } break; case SEND_OBJECT: if (memcmp (code, SC_ACK, 3) == 0) { send_one_commit (processor); } else { g_warning ("[sendcommit] Bad response in state SEND_OBJECT: %s %s\n", code, code_msg); ccnet_processor_done (processor, FALSE); } break; default: g_assert (0); } }
static void process_commit_list (CcnetProcessor *processor, char *content, int clen) { USE_PRIV; char *object_id; int n_objects; int i; if (clen % 41 != 1 || content[clen-1] != '\0') { g_warning ("[getcommit] Bad commit id list.\n"); ccnet_processor_send_update (processor, SC_BAD_OL, SS_BAD_OL, NULL, 0); transfer_task_set_error (((SeafileGetcommitProc *)processor)->tx_task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_done (processor, FALSE); return; } n_objects = clen/41; request_object_batch_begin(priv); object_id = content; for (i = 0; i < n_objects; ++i) { object_id[40] = '\0'; check_commit (processor, object_id); object_id += 41; } request_object_batch_flush (processor, priv); if (priv->pending_objects == 0) { ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0); ccnet_processor_done (processor, TRUE); } }
static void response_challenge_user(CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { unsigned char *buf; int decrypt_len; if (clen == 0) { ccnet_warning("Peer %s(%.8s) send bad format challenge\n", processor->peer->name, processor->peer->id); ccnet_processor_send_response ( processor, SC_BAD_CHALLENGE, SS_BAD_CHALLENGE, NULL, 0); ccnet_processor_done(processor, FALSE); return; } buf = private_key_decrypt(processor->session->user_privkey, (unsigned char *)content, clen, &decrypt_len); if (decrypt_len < 0) { ccnet_processor_send_response ( processor, SC_DECRYPT_ERROR, SS_DECRYPT_ERROR, NULL, 0); ccnet_processor_done(processor, FALSE); } else ccnet_processor_send_response ( processor, code, "", (char *)buf, decrypt_len); g_free(buf); }
static void thread_done (void *result) { CcnetProcessor *processor = result; USE_PRIV; if (processor->delay_shutdown) { ccnet_processor_done (processor, FALSE); return; } if (strcmp (priv->rsp_code, SC_OK) == 0) { if (priv->has_branch) { ccnet_processor_send_response (processor, SC_OK, SS_OK, priv->head_id, 41); } else ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); processor->state = ACCESS_GRANTED; } else { ccnet_processor_send_response (processor, priv->rsp_code, priv->rsp_msg, NULL, 0); ccnet_processor_done (processor, FALSE); } }
void ccnet_service_proxy_invoke_remote (CcnetProcessor *processor, CcnetPeer *remote, int argc, char **argv) { CcnetServiceStubProc *stub_proc; ServiceProxyPriv *priv = GET_PRIV(processor); if (argc < 1) { ccnet_processor_send_response (processor, SC_BAD_CMD_FMT, SS_BAD_CMD_FMT, NULL, 0); ccnet_processor_done (processor, FALSE); return; } priv->name = proc_name_strjoin_n(" ", argc, argv); stub_proc = CCNET_SERVICE_STUB_PROC ( ccnet_proc_factory_create_master_processor ( processor->session->proc_factory, "service-stub", remote) ); priv->stub_proc = stub_proc; ccnet_service_stub_proc_set_proxy_proc (stub_proc, processor); /* Start can fail if the remote end is not connected. */ if (ccnet_processor_start (CCNET_PROCESSOR(stub_proc), argc, argv) < 0) { ccnet_processor_send_response (processor, SC_PROC_DEAD, SS_PROC_DEAD, NULL, 0); ccnet_processor_done (processor, FALSE); } }
static void process_ack (CcnetProcessor *processor, char *content, int clen) { SeafileSendblockV2Proc *proc = (SeafileSendblockV2Proc *)processor; int block_idx; if (content[clen-1] != '\0') { g_warning ("Bad block ack.\n"); ccnet_processor_done (processor, FALSE); return; } block_idx = atoi(content); if (block_idx < 0 || block_idx >= proc->tx_task->block_list->n_blocks) { g_warning ("Bad block index %d.\n", block_idx); ccnet_processor_done (processor, FALSE); return; } BitfieldRem (&proc->active, block_idx); BitfieldRem (&proc->tx_task->active, block_idx); BitfieldAdd (&proc->tx_task->uploaded, block_idx); /* g_debug ("[sendlbock] recv ack for block %d\n", block_idx); */ ++(proc->tx_task->n_uploaded); }
static void handle_update (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { switch (processor->state) { case SEND_OBJECTS: if (strncmp (code, SC_OBJ_LIST_SEG, 3) == 0) { process_object_list_segment (processor, content, clen); return; } else if (strncmp (code, SC_END, 3) == 0) { seaf_debug ("All objects received. Done.\n"); ccnet_processor_done (processor, TRUE); return; } break; default: g_return_if_reached (); } seaf_warning ("Bad update: %s %s.\n", code, code_msg); ccnet_processor_send_response (processor, SC_BAD_UPDATE_CODE, SS_BAD_UPDATE_CODE, NULL, 0); ccnet_processor_done (processor, FALSE); }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendfsProc *proc = (SeafileSendfsProc *)processor; TransferTask *task = proc->tx_task; switch (processor->state) { case SEND_ROOT: if (strncmp(code, SC_OK, 3) == 0) { send_fs_roots (processor); return; } break; case SEND_OBJECT: if (strncmp(code, SC_GET_OBJECT, 3) == 0) { send_fs_objects (processor, content, clen); return; } else if (strncmp(code, SC_END, 3) == 0) { seaf_debug ("Send fs objects end.\n"); ccnet_processor_done (processor, TRUE); return; } break; default: g_assert (0); } g_warning ("Bad response: %s %s.\n", code, code_msg); if (memcmp (code, SC_ACCESS_DENIED, 3) == 0) transfer_task_set_error (task, TASK_ERR_ACCESS_DENIED); ccnet_processor_done (processor, FALSE); }
static int sync_repo_start (CcnetProcessor *processor, int argc, char **argv) { SeafileSyncRepoProc *proc = (SeafileSyncRepoProc *) processor; if (argc != 0) { seaf_warning ("[sync-repo] argc should be 0.\n"); ccnet_processor_done (processor, FALSE); return 0; } if (!proc->task) { seaf_warning ("[sync-repo] Error: not provide info task.\n"); ccnet_processor_done (processor, FALSE); return 0; } char buf[256]; /* Use a virutal "fetch_head" branch that works both on client and server. */ snprintf (buf, 256, "remote %s seafile-sync-repo-slave %s %s", processor->peer_id, proc->task->info->repo_id, "fetch_head"); ccnet_processor_send_request (processor, buf); return 0; }
static int start (CcnetProcessor *processor, int argc, char **argv) { char *session_token; USE_PRIV; if (argc != 1) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } session_token = argv[0]; if (seaf_token_manager_verify_token (seaf->token_mgr, processor->peer_id, session_token, NULL) == 0) { ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); processor->state = RECV_ROOT; priv->dir_queue = g_queue_new (); register_async_io (processor); return 0; } else { ccnet_processor_send_response (processor, SC_ACCESS_DENIED, SS_ACCESS_DENIED, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } }
static void commit_write_cb (OSAsyncResult *res, void *data) { CcnetProcessor *processor = data; TransferTask *task = ((SeafileGetcommitV3Proc *)processor)->tx_task; SeafCommit *commit; if (!res->success) { seaf_warning ("Failed to write commit %.8s.\n", res->obj_id); transfer_task_set_error (task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, FALSE); return; } commit = seaf_commit_from_data (res->obj_id, res->data, res->len); if (!commit) { seaf_warning ("[getcommit] Bad commit object received.\n"); transfer_task_set_error (task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_send_update (processor, SC_BAD_OBJECT, SS_BAD_OBJECT, NULL, 0); ccnet_processor_done (processor, FALSE); return; } if (strcmp (commit->root_id, EMPTY_SHA1) != 0) object_list_insert (task->fs_roots, commit->root_id); seaf_commit_unref (commit); ccnet_processor_done (processor, TRUE); }
static void computation_finished (CcnetProcessor *processor, int status, char *message) { USE_PRIV; g_ptr_array_free (priv->block_ids, TRUE); priv->block_ids = NULL; g_message ("Finished computing size of repo %s.\n", priv->repo_id); /* Store repo size into database. */ if (seaf_monitor_set_repo_size (singleton_monitor, priv->repo_id, priv->repo_size, priv->is_accurate, priv->head) < 0) { ccnet_processor_send_response (processor, SC_DB_ERROR, SS_DB_ERROR, NULL, 0); ccnet_processor_done (processor, FALSE); } ccnet_processor_send_response (processor, SC_FINISHED, SS_FINISHED, NULL, 0); ccnet_processor_done (processor, TRUE); }
static int start (CcnetProcessor *processor, int argc, char **argv) { USE_PRIV; if (argc != 2 || strlen(argv[0]) != 36 || strlen(argv[1]) != 40) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } if (seaf_monitor_is_repo_size_uptodate (singleton_monitor, argv[0], argv[1])) { g_message ("repo size %s is up-to-date.\n", argv[0]); ccnet_processor_send_response (processor, SC_FINISHED, SS_FINISHED, NULL, 0); ccnet_processor_done (processor, TRUE); return 0; } memcpy (priv->repo_id, argv[0], 41); memcpy (priv->head, argv[1], 41); priv->block_ids = g_ptr_array_new_with_free_func (g_free); priv->is_accurate = 1; ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); return 0; }
static void thread_done (void *result) { CcnetProcessor *processor = result; USE_PRIV; if (processor->delay_shutdown) { ccnet_processor_done (processor, FALSE); return; } if (strcmp (priv->rsp_code, SC_OK) == 0) { /* Repo is updated, trigger repo size computation. */ if (seaf->monitor_id != NULL && (strcmp (seaf->monitor_id, seaf->session->base.id) == 0 || ccnet_peer_is_ready (seaf->ccnetrpc_client, seaf->monitor_id))) { monitor_compute_repo_size_async_wrapper (seaf->monitor_id, priv->repo_id, compute_callback, NULL); } ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); ccnet_processor_done (processor, TRUE); } else { ccnet_processor_send_response (processor, priv->rsp_code, priv->rsp_msg, NULL, 0); ccnet_processor_done (processor, FALSE); } }
static void end_or_check_next_dir (CcnetProcessor *processor, SeafileGetfsProcPriv *priv) { if (check_end_condition (priv)) { seaf_debug ("Get fs end.\n"); ccnet_processor_send_update (processor, SC_END, SS_END, NULL, 0); ccnet_processor_done (processor, TRUE); return; } if (priv->worker_running) { return; } /* Trigger checking the next dir. */ char *next_dir_id = g_queue_pop_head (priv->inspect_queue); if (next_dir_id) { if (check_fs_tree_from (processor, next_dir_id) < 0) { transfer_task_set_error (((SeafileGetfsProc *)processor)->tx_task, TASK_ERR_DOWNLOAD_FS); ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, FALSE); } g_free (next_dir_id); } }
static int put_commit_start (CcnetProcessor *processor, int argc, char **argv) { char *commit_id; char *session_token; USE_PRIV; if (argc != 2) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } session_token = argv[1]; if (seaf_token_manager_verify_token (seaf->token_mgr, processor->peer_id, session_token, NULL) < 0) { ccnet_processor_send_response (processor, SC_ACCESS_DENIED, SS_ACCESS_DENIED, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } commit_id = argv[0]; memcpy (priv->commit_id, commit_id, 41); ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); return send_commit_ids (processor, commit_id); }
static void process_get_block (CcnetProcessor *processor, char *content, int clen) { char *space, *block_id; USE_PRIV; if (content[clen-1] != '\0') { ccnet_processor_send_response (processor, SC_BAD_BLK_REQ, SS_BAD_BLK_REQ, NULL, 0); ccnet_processor_done (processor, FALSE); return; } space = strchr (content, ' '); if (!space) { ccnet_processor_send_response (processor, SC_BAD_BLK_REQ, SS_BAD_BLK_REQ, NULL, 0); ccnet_processor_done (processor, FALSE); return; } *space = '\0'; block_id = space + 1; BlockRequest req; req.block_idx = atoi(content); memcpy (req.block_id, block_id, 41); if (pipewriten (priv->tdata->task_pipe[1], &req, sizeof(BlockRequest)) < 0) { g_warning ("[put block] failed to write task pipe.\n"); ccnet_processor_done (processor, FALSE); } }
static int start (CcnetProcessor *processor, int argc, char **argv) { if (argc != 2) { g_warning ("[notifysync-slave] argc(%d) must be 2\n", argc); ccnet_processor_done (processor, FALSE); return -1; } const char *repo_id = argv[0]; const char *token = argv[1]; seaf_debug ("[notifysync-slave] Receive notify sync repo %s from %s\n", repo_id, processor->peer_id); if (!seaf_repo_manager_repo_exists (seaf->repo_mgr, repo_id)) { ccnet_processor_send_response (processor, SC_BAD_REPO, SS_BAD_REPO, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } seaf_sync_manager_add_sync_task (seaf->sync_mgr, repo_id, processor->peer_id, token, TRUE, NULL); ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); ccnet_processor_done (processor, TRUE); return 0; }
static void read_done_cb (OSAsyncResult *res, void *cb_data) { CcnetProcessor *processor = cb_data; USE_PRIV; if (!res->success) { g_warning ("[putcommit] Failed to read %s.\n", res->obj_id); goto bad; } send_commit (processor, res->obj_id, res->data, res->len); seaf_debug ("Send commit %.8s.\n", res->obj_id); /* Send next commit. */ if (priv->id_list != NULL) read_and_send_commit (processor); else { ccnet_processor_send_response (processor, SC_END, SS_END, NULL, 0); ccnet_processor_done (processor, TRUE); } return; bad: ccnet_processor_send_response (processor, SC_NOT_FOUND, SS_NOT_FOUND, NULL, 0); ccnet_processor_done (processor, FALSE); }
static void handle_upload_ok (CcnetProcessor *processor, TransferTask *task, char *content, int clen) { if (clen == 0) { ccnet_processor_send_update (processor, SC_GET_TOKEN, SS_GET_TOKEN, NULL, 0); return; } if (clen != 41 || content[clen-1] != '\0') { g_warning ("Bad response content.\n"); transfer_task_set_error (task, TASK_ERR_UNKNOWN); ccnet_processor_send_update (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return; } memcpy (task->remote_head, content, 41); /* Check fast-forward here. */ if (strcmp (task->head, task->remote_head) != 0 && !is_fast_forward (task->head, task->remote_head)) { g_warning ("Upload is not fast-forward.\n"); transfer_task_set_error (task, TASK_ERR_NOT_FAST_FORWARD); ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, FALSE); return; } ccnet_processor_send_update (processor, SC_GET_TOKEN, SS_GET_TOKEN, NULL, 0); }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendcommitV2Proc *proc = (SeafileSendcommitV2Proc *)processor; TransferTask *task = proc->tx_task; if (task->state != TASK_STATE_NORMAL) { /* TODO: not tested yet */ ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (memcmp (code, SC_OK, 3) == 0) { processor->state = SEND_OBJECT; send_commits (processor, task->head); } else { seaf_warning ("Bad response: %s %s.\n", code, code_msg); ccnet_processor_done (processor, FALSE); } break; case SEND_OBJECT: seaf_warning ("[sendcommit] Bad response in state SEND_OBJECT: %s %s\n", code, code_msg); ccnet_processor_done (processor, FALSE); break; default: g_return_if_reached (); } }
static int sync_repo_slave_start (CcnetProcessor *processor, int argc, char **argv) { USE_PRIV; if (argc != 2) { g_warning ("[sync-repo-slave] argc(%d) must be 2\n", argc); ccnet_processor_done (processor, FALSE); return -1; } memcpy (priv->repo_id, argv[0], 37); priv->branch_name = g_strdup (argv[1]); /* send the head commit of the branch */ if (ccnet_processor_thread_create (processor, seaf->job_mgr, send_repo_branch_info, thread_done, processor) < 0) { g_warning ("[sync repo] failed to start thread.\n"); ccnet_processor_send_response (processor, SC_SERVER_ERROR, SS_SERVER_ERROR, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } return 0; }
static int start (CcnetProcessor *processor, int argc, char **argv) { char *session_token; USE_PRIV; if (argc != 1) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } session_token = argv[0]; if (seaf_token_manager_verify_token (seaf->token_mgr, NULL, processor->peer_id, session_token, priv->repo_id) == 0) { ccnet_processor_thread_create (processor, seaf->job_mgr, get_repo_info_thread, get_repo_info_done, processor); return 0; } else { ccnet_processor_send_response (processor, SC_ACCESS_DENIED, SS_ACCESS_DENIED, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } }
static int recv_commit_start (CcnetProcessor *processor, int argc, char **argv) { USE_PRIV; char *session_token; if (argc != 2) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } session_token = argv[1]; if (seaf_token_manager_verify_token (seaf->token_mgr, processor->peer_id, session_token, NULL) == 0) { ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); processor->state = RECV_OBJECT; priv->writer_id = seaf_obj_store_register_async_write (seaf->commit_mgr->obj_store, write_done_cb, processor); priv->registered = TRUE; return 0; } else { ccnet_processor_send_response (processor, SC_ACCESS_DENIED, SS_ACCESS_DENIED, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendcommitV3Proc *proc = (SeafileSendcommitV3Proc *)processor; TransferTask *task = proc->tx_task; if (task->state != TASK_STATE_NORMAL) { ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (memcmp (code, SC_OK, 3) == 0) { processor->state = SEND_OBJECT; send_commits (processor, task->head); return; } break; case SEND_OBJECT: if (memcmp (code, SC_ACK, 3) == 0) { send_one_commit (processor); return; } break; default: g_return_if_reached (); } g_warning ("Bad response: %s %s.\n", code, code_msg); if (memcmp (code, SC_ACCESS_DENIED, 3) == 0) transfer_task_set_error (task, TASK_ERR_ACCESS_DENIED); ccnet_processor_done (processor, FALSE); }
void ccnet_processor_handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { if ((code[0] == '5' || code[0] == '4') && !CCNET_IS_KEEPALIVE2_PROC(processor)) { ccnet_warning ("[Proc] peer %.10s, Shutdown processor %s(%d) for bad response: %s %s\n", processor->peer->id, GET_PNAME(processor), PRINT_ID(processor->id), code, code_msg); /* Stub proc should relay the message before it shuts down. */ if (CCNET_IS_SERVICE_PROXY_PROC(processor) || CCNET_IS_SERVICE_STUB_PROC(processor)) { CCNET_PROCESSOR_GET_CLASS (processor)->handle_response ( processor, code, code_msg, content, clen); } if (memcmp(code, SC_UNKNOWN_SERVICE, 3) == 0) processor->failure = PROC_NO_SERVICE; else if (memcmp(code, SC_PERM_ERR, 3) == 0) processor->failure = PROC_PERM_ERR; else if (memcmp(code, SC_CON_TIMEOUT, 3) == 0) processor->failure = PROC_CON_TIMEOUT; else if (memcmp(code, SC_KEEPALIVE_TIMEOUT, 3) == 0) processor->failure = PROC_TIMEOUT; else if (memcmp(code, SC_NETDOWN, 3) == 0) processor->failure = PROC_NETDOWN; else processor->failure = PROC_BAD_RESP; ccnet_processor_done (processor, FALSE); return; } processor->t_packet_recv = time(NULL); if (memcmp (code, SC_PROC_KEEPALIVE, 3) == 0) { ccnet_processor_keep_alive_response (processor); } else if (memcmp (code, SC_PROC_ALIVE, 3) == 0) { /* do nothing */ } else if (memcmp (code, SC_PROC_DEAD, 3) == 0) { ccnet_debug ("[Proc] Shutdown processor %s(%d) when remote processor dies\n", GET_PNAME(processor), PRINT_ID(processor->id)); if (CCNET_IS_SERVICE_PROXY_PROC(processor) || CCNET_IS_SERVICE_STUB_PROC(processor)) { CCNET_PROCESSOR_GET_CLASS (processor)->handle_response ( processor, code, code_msg, content, clen); } processor->failure = PROC_REMOTE_DEAD; ccnet_processor_done (processor, FALSE); } else CCNET_PROCESSOR_GET_CLASS (processor)->handle_response (processor, code, code_msg, content, clen); }
static int put_commit_start (CcnetProcessor *processor, int argc, char **argv) { char *head_id, *remote_id = NULL; char *session_token; USE_PRIV; if (argc < 2) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } if (argc == 2) { head_id = argv[0]; session_token = argv[1]; } else if (argc >= 3) { head_id = argv[0]; remote_id = argv[1]; session_token = argv[2]; } if (strlen(head_id) != 40 || (remote_id && strlen(remote_id) != 40)) { ccnet_processor_send_response (processor, SC_BAD_ARGS, SS_BAD_ARGS, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } if (seaf_token_manager_verify_token (seaf->token_mgr, processor->peer_id, session_token, NULL) < 0) { ccnet_processor_send_response (processor, SC_ACCESS_DENIED, SS_ACCESS_DENIED, NULL, 0); ccnet_processor_done (processor, FALSE); return -1; } memcpy (priv->head_commit_id, head_id, 41); if (remote_id != NULL) memcpy (priv->remote_commit_id, remote_id, 41); ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); priv->reader_id = seaf_obj_store_register_async_read (seaf->commit_mgr->obj_store, read_done_cb, processor); priv->registered = TRUE; ccnet_processor_thread_create (processor, seaf->job_mgr, collect_commit_id_thread, collect_commit_id_done, processor); return 0; }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileGetcommitProc *proc = (SeafileGetcommitProc *)processor; if (proc->tx_task->state != TASK_STATE_NORMAL) { /* TODO: not tested yet */ ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (strncmp(code, SC_OK, 3) == 0) { processor->state = RECV_IDS; } else { g_warning ("[getcommit] Bad response: %s %s\n", code, code_msg); transfer_task_set_error (proc->tx_task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_done (processor, FALSE); } break; case RECV_IDS: if (strncmp(code, SC_COMMIT_IDS, 3) == 0) { /* add to inspect queue */ process_commit_list (processor, content, clen); } else if (strncmp(code, SC_END, 3) == 0) { /* change state to FETCH_OBJECT */ processor->state = FETCH_OBJECT; } else { g_warning ("[getcommit] Bad response: %s %s\n", code, code_msg); transfer_task_set_error (proc->tx_task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_done (processor, FALSE); } break; case FETCH_OBJECT: if (strncmp(code, SC_OBJECT, 3) == 0) { receive_commit (processor, content, clen); } else { g_warning ("[getcommit] Bad response: %s %s\n", code, code_msg); /* Transfer the task state to error when an error ocurred */ transfer_task_set_error (proc->tx_task, TASK_ERR_DOWNLOAD_COMMIT); ccnet_processor_done (processor, FALSE); } break; default: g_assert (0); } }
static void handle_update (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { USE_PRIV; if (strcmp(code, SC_SESSION_KEY) == 0) { if (processor->peer->session_key) { ccnet_processor_send_response (processor, SC_ALREADY_HAS_KEY, SS_ALREADY_HAS_KEY, NULL, 0); ccnet_processor_done (processor, TRUE); return; } if (update_peer_session_key (processor->peer, content, clen) < 0) { ccnet_processor_send_response (processor, SC_BAD_KEY, SS_BAD_KEY, NULL, 0); ccnet_processor_done (processor, FALSE); return; } if (priv->encrypt_channel) { /* peer ask to encrypt channel, check whether we want it too */ if (ccnet_session_should_encrypt_channel(processor->session)) { /* send the ok reply first */ ccnet_processor_send_response (processor, SC_OK, SS_OK, NULL, 0); /* now setup encryption */ if (ccnet_peer_prepare_channel_encryption (processor->peer) < 0) /* this is very rare, we just print a warning */ ccnet_warning ("Error in prepare channel encryption\n"); } else ccnet_processor_send_response ( processor, SC_NO_ENCRYPT, SS_NO_ENCRYPT, NULL, 0); } else ccnet_processor_send_response ( processor, SC_OK, SS_OK, NULL, 0); ccnet_peer_manager_on_peer_session_key_received (processor->peer->manager, processor->peer); ccnet_processor_done (processor, TRUE); return; } ccnet_warning ("[recv session key] bad update %s:%s\n", code, code_msg); ccnet_processor_done (processor, FALSE); }