C++ (Cpp) mchecksum_init Examples

Example #1

File: test_mchecksum.c Project: ddn-lixi/mtfs

int main()
{
	__u32 checksum1 = 0;
	__u32 checksum2 = 0;
	char input[MAX_MOUNT_OPTION_LENGTH];
	int ret = 0;
	mchecksum_type_t type = mchecksum_type_select();
	int number = 0;
	int again = 0;

	checksum1 = mchecksum_init(type);
	checksum2 = mchecksum_init(type);
	while (1) {
		ret = fscanf(stdin, "%s", input);
		if (ret == EOF) {
			if (!again) {
				fprintf(stderr ,"invalid input\n");
				ret = -EINVAL;
				goto out;
			} else {
				break;
			}
		} else if (strlen(input) == AGAIN_SLOT_LEN &&
			   strcmp(input, AGAIN_SLOT) == 0) {
			again = 1;
			continue;
		} else {
			if (!again) {
				checksum1 = mchecksum_compute(checksum1, input,
				                  strlen(input), type);
			} else {
				checksum2 = mchecksum_compute(checksum2, input,
				                  strlen(input), type);
			}
		}
	}

	if (checksum1 == checksum2) {
		printf("equal\n");
	} else {
		printf("differ\n");
	}
	ret = 0;
out:
	return ret;
}

Example #2

File: mercury_proc.c Project: jolivier23/mercury

/*---------------------------------------------------------------------------*/
hg_return_t
hg_proc_create(hg_class_t *hg_class, void *buf, hg_size_t buf_size,
    hg_proc_op_t op, hg_proc_hash_t hash, hg_proc_t *proc)
{
    struct hg_proc *hg_proc = NULL;
    const char *hash_method;
    hg_return_t ret = HG_SUCCESS;

    if (!hg_class) {
        HG_LOG_ERROR("NULL HG class");
        ret = HG_INVALID_PARAM;
        goto done;
    }

    if (!buf && op != HG_FREE) {
        HG_LOG_ERROR("NULL buffer");
        ret = HG_INVALID_PARAM;
        goto done;
    }

    hg_proc = (struct hg_proc *) malloc(sizeof(struct hg_proc));
    if (!hg_proc) {
        HG_LOG_ERROR("Could not allocate proc");
        ret = HG_NOMEM_ERROR;
        goto done;
    }

    hg_proc->hg_class = hg_class;
    hg_proc->op = op;
    hg_proc->proc_buf.buf = buf;
    hg_proc->proc_buf.size = buf_size;
    hg_proc->proc_buf.buf_ptr = buf;
    hg_proc->proc_buf.size_left = buf_size;
    hg_proc->proc_buf.is_mine = 0;
#ifdef HG_HAS_CHECKSUMS
    hg_proc->proc_buf.checksum = MCHECKSUM_OBJECT_NULL;
    hg_proc->proc_buf.update_checksum = 0;
#endif
#ifdef HG_HAS_XDR
    switch (op) {
        case HG_ENCODE:
            xdrmem_create(&hg_proc->proc_buf.xdr, (char *) buf, buf_size, XDR_ENCODE);
            break;
        case HG_DECODE:
            xdrmem_create(&hg_proc->proc_buf.xdr, (char *) buf, buf_size, XDR_DECODE);
            break;
        case HG_FREE:
            xdrmem_create(&hg_proc->proc_buf.xdr, (char *) buf, buf_size, XDR_FREE);
            break;
        default:
            HG_LOG_ERROR("Unknown proc operation");
            ret = HG_INVALID_PARAM;
            goto done;
    }
#endif

    /* Map enum to string */
    switch (hash) {
        case HG_CRC16:
            hash_method = "crc16";
            break;
        case HG_CRC64:
            hash_method = "crc64";
            break;
        default:
            hash_method = NULL;
            break;
    }

    if (hash_method) {
#ifdef HG_HAS_CHECKSUMS
        int checksum_ret;

        checksum_ret = mchecksum_init(hash_method,
                &hg_proc->proc_buf.checksum);
        if (checksum_ret != MCHECKSUM_SUCCESS) {
            HG_LOG_ERROR("Could not initialize checksum");
            ret = HG_CHECKSUM_ERROR;
            goto done;
        }
        hg_proc->proc_buf.update_checksum = 1;
#endif
    }

    /* Do not allocate extra buffer yet */
    hg_proc->extra_buf.buf = NULL;
    hg_proc->extra_buf.size = 0;
    hg_proc->extra_buf.buf_ptr = NULL;
    hg_proc->extra_buf.size_left = 0;
    hg_proc->extra_buf.is_mine = 0;
#ifdef HG_HAS_CHECKSUMS
    hg_proc->extra_buf.checksum = hg_proc->proc_buf.checksum;
    hg_proc->extra_buf.update_checksum = hg_proc->proc_buf.update_checksum;
#endif

    /* Default to proc_buf */
    hg_proc->current_buf = &hg_proc->proc_buf;

    *proc = (struct hg_proc *) hg_proc;

done:
    if (ret != HG_SUCCESS) {
        free(hg_proc);
    }
    return ret;
}