string MessageHandler::handlePsiHashDataFinished()

in samplecode/psi/MessageHandler/MessageHandler.cpp [494:576]
68 lines of code
13 McCabe index (conditional complexity)

string MessageHandler::handlePsiHashDataFinished(Messages::MessagePsiHashDataFinished msg, bool* again) {

    sgx_ra_context_t context = msg.context();
    uint32_t id = msg.id();
    uint8_t mac[SGX_MAC_SIZE] = {0};
    uint8_t * data = NULL;
    size_t data_size = 0;
    sgx_status_t status;
    sgx_status_t ret;

    Log("[PSI] Received hash data finished, %d", id);

    ret = get_result_size(this->enclave->getID(), &status, id, &data_size);
    if (SGX_SUCCESS != ret) {
        Log("[PSI] get_result_size failed, %d", ret);
        return "";
    }

    if (SGX_SUCCESS != status) {
        if (status == SGX_ERROR_INVALID_STATE) {
            *again = true;

            Messages::MessagePsiResult result;
            result.set_type(RA_PSI_RESULT);
            result.set_size(0);
            result.set_state(1); //tell sp req result again
            result.set_context(msg.context());
            result.set_id(msg.id());

            Log("[PSI] has not calc result success");

            return nm->serialize(result);
        } else {
            Log("[PSI] get_result_size failed, %d, %d", ret, status);
            return "";
        }
    }

    if (data_size > 0) {
        data = (uint8_t*)malloc(data_size);
        if (data == NULL) {
            Log("[PSI] alloc buffer for intersect data failed!");
            return "";
        }

        ret = get_result(this->enclave->getID(),
                        &status,
                        id,
                        context,
                        data,
                        data_size,
                        mac);
        if (SGX_SUCCESS != ret || SGX_SUCCESS != status) {
            Log("[PSI] get_result failed, %d, %d", ret, status);
            return "";
        }
    }

    Messages::MessagePsiIntersect intersect;
    intersect.set_type(RA_PSI_INTERSECT);
    intersect.set_size(0);
    intersect.set_id(msg.id());
    intersect.set_context(context);

    for (int i = 0; i < SGX_MAC_SIZE; i++) {
        intersect.add_mac(mac[i]);
    }

    if (data && data_size) {
        for (int i = 0; i < data_size; i++) {
            intersect.add_data(data[i]);
        }
    }
    if (data) {
        SafeFree(data);
    }

    enclave_ra_close(this->enclave->getID(), &status, context);

    Log("[PSI] get result success, %d", data_size/SGX_HASH_SIZE);

    return nm->serialize(intersect);
}