view release on metacpan or  search on metacpan

types.c  view on Meta::CPAN

static unsigned long
trustmask(char *str, STRLEN len)
{
	unsigned long flags;

	if(len == 5 && strncmp(str, "never", 5) == 0){
		return 0;
	}

	if(len < 8){
		goto badstr;
	}else if(strncmp(str, "required", 8) == 0){
		flags = MASK_ENABLE;
	}else if(strncmp(str, "optional", 8) == 0){
		flags = MASK_OPT;
	}else {
		goto badstr;
	}

	if(len == 8){
		/* Conveniently, the strings "required" and "optional" are both 8 characters long. */
		return flags;
	}else if(len != 17 || strncmp(str + 8, " trustall", 8) != 0){
		goto badstr;
	}
	return flags | MASK_TRUSTALL;

	badstr:
	croak("Unrecognized signature level string: %s", str);
}

static unsigned long
fetch_trustmask(HV *hv, const char *key){
	SV **val;
	char *str;
	STRLEN len;

	val = hv_fetch(hv, key, strlen(key), 0);
	if(val == NULL){
		croak("Invalid signature level hash: %s key is missing", key);
	}
	str = SvPV(*val, len);
	return trustmask(str, len);
}

/* converts a siglevel string or hashref into bitflags. */
alpm_siglevel_t
p2c_siglevel(SV *sig)
{
	char *str;
	STRLEN len;
	alpm_siglevel_t ret;
	HV *hv;

	if(SvPOK(sig)){
		str = SvPV(sig, len);
		if(len == 7 && strncmp(str, "default", len) == 0){
			return ALPM_SIG_USE_DEFAULT;
		}else {
			/* XXX: might not be null terminated? */
			croak("Unrecognized global signature level string: %s", str);
		}
	}else if(SvROK(sig) && SvTYPE(SvRV(sig)) == SVt_PVHV){
		hv = (HV*)SvRV(sig);
		ret = fetch_trustmask(hv, "pkg");
		ret |= fetch_trustmask(hv, "db") << OFFSET_DB;
		return ret;
	}
	croak("A global signature level must be a string or hash reference");
}

#undef MASK_ENABLE
#undef MASK_OPT
#undef MASK_TRUSTALL
#undef MASK_ALL
#undef OFFSET_DB

SV*
c2p_pkgreason(alpm_pkgreason_t rsn)
{
	switch(rsn){
	case ALPM_PKG_REASON_EXPLICIT:
		return newSVpv("explicit", 0);
	case ALPM_PKG_REASON_DEPEND:
		return newSVpv("implicit", 0);
	}

	croak("unrecognized pkgreason enum");
}

alpm_pkgreason_t
p2c_pkgreason(SV *sv)
{
	STRLEN len;
	char *rstr;

	if(SvIOK(sv)){
		switch(SvIV(sv)){
		case 0: return ALPM_PKG_REASON_EXPLICIT;
		case 1: return ALPM_PKG_REASON_DEPEND;
		}
		croak("integer reasons must be 0 or 1");
	}else if(SvPOK(sv)){
		rstr = SvPV(sv, len);
		if(strncmp(rstr, "explicit", len) == 0){
			return ALPM_PKG_REASON_EXPLICIT;
		}else if(strncmp(rstr, "implicit", len) == 0
			|| strncmp(rstr, "depend", len) == 0){
			return ALPM_PKG_REASON_DEPEND;
		}else{
			croak("string reasons can only be explicit or implicit/depend");
		}
	}else{
		croak("reasons can only be integers or strings");
	}
}

SV *
c2p_pkgfrom(alpm_pkgfrom_t from)
{
	char *str;

	switch(from){
	case ALPM_PKG_FROM_FILE: str = "file"; break;
	case ALPM_PKG_FROM_LOCALDB: str = "localdb"; break;
	case ALPM_PKG_FROM_SYNCDB: str = "syncdb"; break;
	default: str = "unknown"; break;
	}