static bool
get_dvbc_tune_params(uint16_t service_id, struct dvb_frontend_parameters *out)
{
char line[1024];
unsigned int freq;
char inv[32];
unsigned int sr;
char fec[32];
char mod[32];
unsigned int id;
int len;
while(!feof(_channels))
{
if(fgets(line, sizeof(line), _channels) == NULL
|| sscanf(line, "%*[^:]:%u:%32[^:]:%u:%32[^:]:%32[^:]:%*[^:]:%*[^:]:%u", &freq, inv, &sr, fec, mod, &id) != 6
|| id != service_id)
continue;
/* chop off trailing \n */
len = strlen(line) - 1;
while(len >= 0 && line[len] == '\n')
line[len--] = '\0';
verbose("%s", line);
out->frequency = freq;
out->inversion = str2enum(inv, inversion_list, LIST_SIZE(inversion_list));
out->u.qam.symbol_rate = sr;
out->u.qam.fec_inner = str2enum(fec, fec_list, LIST_SIZE(fec_list));
out->u.qam.modulation = str2enum(mod, qam_list, LIST_SIZE(qam_list));
return true;
}
return false;
}
static jose_io_t *
hsh(const jose_hook_alg_t *alg, jose_cfg_t *cfg, jose_io_t *next)
{
jose_io_auto_t *io = NULL;
const EVP_MD *md = NULL;
io_t *i = NULL;
switch (str2enum(alg->name, "S512", "S384", "S256", "S224", "S1", NULL)) {
case 0: md = EVP_sha512(); break;
case 1: md = EVP_sha384(); break;
case 2: md = EVP_sha256(); break;
case 3: md = EVP_sha224(); break;
case 4: md = EVP_sha1(); break;
}
i = calloc(1, sizeof(*i));
if (!i)
return NULL;
io = jose_io_incref(&i->io);
io->feed = hsh_feed;
io->done = hsh_done;
io->free = hsh_free;
i->next = jose_io_incref(next);
i->emc = EVP_MD_CTX_new();
if (!i->next || !i->emc)
return NULL;
if (EVP_DigestInit(i->emc, md) <= 0)
return NULL;
return jose_io_incref(io);
}
/* Get the enumerated module value given a module string.
*
* On error, -1 is returned.
* On success, the enumerated module value is returned. */
int
get_module_enum (const char *str)
{
/* String modules to enumerated modules */
GEnum enum_modules[] = {
{"VISITORS", VISITORS},
{"REQUESTS", REQUESTS},
{"REQUESTS_STATIC", REQUESTS_STATIC},
{"NOT_FOUND", NOT_FOUND},
{"HOSTS", HOSTS},
{"OS", OS},
{"BROWSERS", BROWSERS},
{"VISIT_TIMES", VISIT_TIMES},
{"VIRTUAL_HOSTS", VIRTUAL_HOSTS},
{"REFERRERS", REFERRERS},
{"REFERRING_SITES", REFERRING_SITES},
{"KEYPHRASES", KEYPHRASES},
#ifdef HAVE_LIBGEOIP
{"GEO_LOCATION", GEO_LOCATION},
#endif
{"STATUS_CODES", STATUS_CODES},
};
return str2enum (enum_modules, ARRAY_SIZE (enum_modules), str);
}
static bool
get_atsc_tune_params(uint16_t service_id, struct dvb_frontend_parameters *out)
{
char line[1024];
unsigned int freq;
char mod[32];
unsigned int id;
int len;
while(!feof(_channels))
{
if(fgets(line, sizeof(line), _channels) == NULL
|| sscanf(line, "%*[^:]:%u:%32[^:]:%*[^:]:%*[^:]:%u", &freq, mod, &id) != 3
|| id != service_id)
continue;
/* chop off trailing \n */
len = strlen(line) - 1;
while(len >= 0 && line[len] == '\n')
line[len--] = '\0';
verbose("%s", line);
out->frequency = freq;
/* out->inversion is not set by azap */
out->u.vsb.modulation = str2enum(mod, qam_list, LIST_SIZE(qam_list));
return true;
}
return false;
}
static const char *
alg_sign_sug(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
const char *name = NULL;
const char *type = NULL;
size_t len = 0;
if (json_unpack((json_t *) jwk, "{s?s,s?s}",
"alg", &name, "kty", &type) < 0)
return NULL;
if (name)
return str2enum(name, NAMES, NULL) != SIZE_MAX ? name : NULL;
if (!type || strcmp(type, "RSA") != 0)
return NULL;
len = jose_b64_dec(json_object_get(jwk, "n"), NULL, 0) * 8;
switch ((len < 4096 ? len : 4096) & (4096 | 3072 | 2048)) {
case 4096: return "RS512";
case 3072: return "RS384";
case 2048: return "RS256";
default: return NULL;
}
}
static const char *
alg_exch_sug(const jose_hook_alg_t *alg, jose_cfg_t *cfg,
const json_t *prv, const json_t *pub)
{
const char *crva = NULL;
const char *crvb = NULL;
const char *ktya = NULL;
const char *ktyb = NULL;
if (json_unpack((json_t *) prv, "{s:s,s:s}", "kty", &ktya, "crv", &crva) < 0)
return NULL;
if (json_unpack((json_t *) pub, "{s:s,s:s}", "kty", &ktyb, "crv", &crvb) < 0)
return NULL;
if (strcmp("EC", ktya) != 0 || strcmp("EC", ktyb) != 0)
return NULL;
if (strcmp(crva, crvb) != 0)
return NULL;
if (str2enum(crva, "P-256", "P-384", "P-521", NULL) == SIZE_MAX)
return NULL;
return "ECDH";
}
int
interp_str2enum(const char* s, enum e_interp_t* result, struct driz_error_t* error) {
if (str2enum(s, interp_string_table, (int *)result, error)) {
driz_error_format_message(error, "Unknown interp type '%s'", s);
return 1;
}
return 0;
}
static json_int_t
alg2len(const char *alg)
{
switch (str2enum(alg, NAMES, NULL)) {
case 0: return 16;
case 1: return 24;
case 2: return 32;
default: return 0;
}
}
static const char *
alg_wrap_enc(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
switch (str2enum(alg->name, NAMES, NULL)) {
case 0: return "A128CBC-HS256";
case 1: return "A192CBC-HS384";
case 2: return "A256CBC-HS512";
default: return NULL;
}
}
static bool
jwk_prep_handles(jose_cfg_t *cfg, const json_t *jwk)
{
const char *alg = NULL;
if (json_unpack((json_t *) jwk, "{s:s}", "alg", &alg) == -1)
return false;
return str2enum(alg, NAMES, NULL) != SIZE_MAX;
}
/* string to option value ------------------------------------------------------
* convert string to option value
* args : opt_t *opt O option
* char *str I option value string
* return : status (1:ok,0:error)
*-----------------------------------------------------------------------------*/
extern int str2opt(opt_t *opt, const char *str)
{
switch (opt->format) {
case 0: *(int *)opt->var=atoi(str); break;
case 1: *(double *)opt->var=atof(str); break;
case 2: strcpy((char *)opt->var,str); break;
case 3: return str2enum(str,opt->comment,(int *)opt->var);
default: return 0;
}
return 1;
}
static EVP_MD_CTX *
setup(jose_cfg_t *cfg, const json_t *jwk, const json_t *sig, const char *alg,
init_t *func)
{
openssl_auto(EVP_PKEY) *key = NULL;
EVP_PKEY_CTX *epc = NULL;
const EVP_MD *md = NULL;
EVP_MD_CTX *emc = NULL;
const RSA *rsa = NULL;
int slen = 0;
int pad = 0;
switch (str2enum(alg, NAMES, NULL)) {
case 0: md = EVP_sha256(); pad = RSA_PKCS1_PADDING; break;
case 1: md = EVP_sha384(); pad = RSA_PKCS1_PADDING; break;
case 2: md = EVP_sha512(); pad = RSA_PKCS1_PADDING; break;
case 3: md = EVP_sha256(); pad = RSA_PKCS1_PSS_PADDING; slen = -1; break;
case 4: md = EVP_sha384(); pad = RSA_PKCS1_PSS_PADDING; slen = -1; break;
case 5: md = EVP_sha512(); pad = RSA_PKCS1_PSS_PADDING; slen = -1; break;
default: return NULL;
}
key = jose_openssl_jwk_to_EVP_PKEY(cfg, jwk);
if (!key || EVP_PKEY_base_id(key) != EVP_PKEY_RSA)
return NULL;
/* Don't use small keys. RFC 7518 3.3 */
rsa = EVP_PKEY_get0_RSA(key);
if (!rsa)
return NULL;
if (RSA_size(rsa) < 2048 / 8)
return NULL;
emc = EVP_MD_CTX_new();
if (!emc)
return NULL;
if (func(emc, &epc, md, NULL, key) <= 0)
goto error;
if (EVP_PKEY_CTX_set_rsa_padding(epc, pad) <= 0)
goto error;
if (slen != 0) {
if (EVP_PKEY_CTX_set_rsa_pss_saltlen(epc, slen) <= 0)
goto error;
}
return emc;
error:
EVP_MD_CTX_free(emc);
return NULL;
}
static const char *
alg_wrap_enc(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
const char *crv = NULL;
if (json_unpack((json_t *) jwk, "{s?s}", "crv", &crv) < 0)
return NULL;
switch (str2enum(crv, "P-256", "P-384", "P-521", NULL)) {
case 0: return "A128GCM";
case 1: return "A192GCM";
case 2: return "A256GCM";
default: return NULL;
}
}
static const char *
alg_wrap_alg(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
const char *name = NULL;
const char *type = NULL;
const char *curv = NULL;
if (json_unpack((json_t *) jwk, "{s?s,s?s,s?s}",
"alg", &name, "kty", &type, "crv", &curv) < 0)
return NULL;
if (name)
return str2enum(name, NAMES, NULL) != SIZE_MAX ? name : NULL;
if (!type || strcmp(type, "EC") != 0)
return NULL;
switch (str2enum(curv, "P-256", "P-384", "P-521", NULL)) {
case 0: return "ECDH-ES+A128KW";
case 1: return "ECDH-ES+A192KW";
case 2: return "ECDH-ES+A256KW";
default: return NULL;
}
}
static bool
get_dvbt_tune_params(uint16_t service_id, struct dvb_frontend_parameters *out)
{
char line[1024];
unsigned int freq;
char inv[32];
char bw[32];
char hp[32];
char lp[32];
char qam[32];
char trans[32];
char gi[32];
char hier[32];
unsigned int id;
int len;
while(!feof(_channels))
{
if(fgets(line, sizeof(line), _channels) == NULL
|| sscanf(line, "%*[^:]:%u:%32[^:]:%32[^:]:%32[^:]:%32[^:]:%32[^:]:%32[^:]:%32[^:]:%32[^:]:%*[^:]:%*[^:]:%u", &freq, inv, bw, hp, lp, qam, trans, gi, hier, &id) != 10
|| id != service_id)
continue;
/* chop off trailing \n */
len = strlen(line) - 1;
while(len >= 0 && line[len] == '\n')
line[len--] = '\0';
verbose("%s", line);
out->frequency = freq;
out->inversion = str2enum(inv, inversion_list, LIST_SIZE(inversion_list));
out->u.ofdm.bandwidth = str2enum(bw, bw_list, LIST_SIZE(bw_list));
out->u.ofdm.code_rate_HP = str2enum(hp, fec_list, LIST_SIZE(fec_list));
out->u.ofdm.code_rate_LP = str2enum(lp, fec_list, LIST_SIZE(fec_list));
out->u.ofdm.constellation = str2enum(qam, qam_list, LIST_SIZE(qam_list));
out->u.ofdm.transmission_mode = str2enum(trans, transmissionmode_list, LIST_SIZE(transmissionmode_list));
out->u.ofdm.guard_interval = str2enum(gi, guard_list, LIST_SIZE(guard_list));
out->u.ofdm.hierarchy_information = str2enum(hier, hierarchy_list, LIST_SIZE(hierarchy_list));
return true;
}
return false;
}
static json_t *
jwk_prep_execute(jose_cfg_t *cfg, const json_t *jwk)
{
const char *alg = NULL;
const char *grp = NULL;
if (json_unpack((json_t *) jwk, "{s:s}", "alg", &alg) == -1)
return NULL;
switch (str2enum(alg, NAMES, NULL)) {
case 0: grp = "P-521"; break;
case 1: grp = "P-256"; break;
case 2: grp = "P-384"; break;
case 3: grp = "P-521"; break;
default: return NULL;
}
return json_pack("{s:{s:s,s:s}}", "upd", "kty", "EC", "crv", grp);
}
static const char *
alg_wrap_alg(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
const char *name = NULL;
const char *type = NULL;
if (json_unpack((json_t *) jwk, "{s?s,s?s}",
"alg", &name, "kty", &type) < 0)
return NULL;
if (name)
return str2enum(name, NAMES, NULL) != SIZE_MAX ? name : NULL;
if (!type || strcmp(type, "RSA") != 0)
return NULL;
#ifdef HAVE_OAEP
return "RSA-OAEP";
#else
return "RSA1_5";
#endif
}
static const char *
alg_wrap_alg(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwk)
{
const char *name = NULL;
const char *type = NULL;
if (json_unpack((json_t *) jwk, "{s?s,s?s}",
"alg", &name, "kty", &type) < 0)
return NULL;
if (name)
return str2enum(name, NAMES, NULL) != SIZE_MAX ? name : NULL;
if (!type || strcmp(type, "oct") != 0)
return NULL;
switch (jose_b64_dec(json_object_get(jwk, "k"), NULL, 0)) {
case 16: return "A128KW";
case 24: return "A192KW";
case 32: return "A256KW";
default: return NULL;
}
}
int
get_module_enum (const char *str)
{
return str2enum (MODULES, ARRAY_SIZE (MODULES), str);
}
/* Get the enumerated color given its equivalent color string.
*
* On error, -1 is returned.
* On success, the enumerated color is returned. */
static int
get_color_item_enum (const char *str)
{
return str2enum (CSTM_COLORS, ARRAY_SIZE (CSTM_COLORS), str);
}
static bool
alg_wrap_wrp(const jose_hook_alg_t *alg, jose_cfg_t *cfg, json_t *jwe,
json_t *rcp, const json_t *jwk, json_t *cek)
{
openssl_auto(EVP_PKEY_CTX) *epc = NULL;
openssl_auto(EVP_PKEY) *key = NULL;
const EVP_MD *md = NULL;
const RSA *rsa = NULL;
uint8_t *pt = NULL;
uint8_t *ct = NULL;
bool ret = false;
size_t ptl = 0;
size_t ctl = 0;
int tmp = 0;
int pad = 0;
if (!json_object_get(cek, "k") && !jose_jwk_gen(cfg, cek))
return false;
switch (str2enum(alg->name, NAMES, NULL)) {
case 0: pad = RSA_PKCS1_PADDING; tmp = 11; md = EVP_sha1(); break;
case 1: pad = RSA_PKCS1_OAEP_PADDING; tmp = 41; md = EVP_sha1(); break;
case 2: pad = RSA_PKCS1_OAEP_PADDING; tmp = 41; md = EVP_sha256(); break;
default: return false;
}
key = jose_openssl_jwk_to_EVP_PKEY(cfg, jwk);
if (!key || EVP_PKEY_base_id(key) != EVP_PKEY_RSA)
return false;
ptl = jose_b64_dec(json_object_get(cek, "k"), NULL, 0);
if (ptl == SIZE_MAX)
return false;
rsa = EVP_PKEY_get0_RSA(key);
if (!rsa)
return false;
if ((int) ptl >= RSA_size(rsa) - tmp)
return false;
epc = EVP_PKEY_CTX_new(key, NULL);
if (!epc)
return false;
if (EVP_PKEY_encrypt_init(epc) <= 0)
return false;
if (EVP_PKEY_CTX_set_rsa_padding(epc, pad) <= 0)
return false;
if (pad == RSA_PKCS1_OAEP_PADDING) {
if (EVP_PKEY_CTX_set_rsa_oaep_md(epc, md) <= 0)
return false;
if (EVP_PKEY_CTX_set_rsa_mgf1_md(epc, md) <= 0)
return false;
}
pt = malloc(ptl);
if (!pt)
return false;
if (jose_b64_dec(json_object_get(cek, "k"), pt, ptl) != ptl)
goto egress;
if (EVP_PKEY_encrypt(epc, NULL, &ctl, pt, ptl) <= 0)
goto egress;
ct = malloc(ctl);
if (!ct)
goto egress;
if (EVP_PKEY_encrypt(epc, ct, &ctl, pt, ptl) <= 0)
goto egress;
if (json_object_set_new(rcp, "encrypted_key", jose_b64_enc(ct, ctl)) < 0)
goto egress;
ret = add_entity(jwe, rcp, "recipients", "header", "encrypted_key", NULL);
egress:
if (pt) {
OPENSSL_cleanse(pt, ptl);
free(pt);
}
free(ct);
return ret;
}
int
get_sort_order_enum (const char *str)
{
return str2enum (ORDER, ARRAY_SIZE (ORDER), str);
}
static bool
alg_wrap_unw(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwe,
const json_t *rcp, const json_t *jwk, json_t *cek)
{
openssl_auto(EVP_PKEY_CTX) *epc = NULL;
openssl_auto(EVP_PKEY) *key = NULL;
const uint8_t *tt = NULL;
const EVP_MD *md = NULL;
uint8_t *ct = NULL;
uint8_t *pt = NULL;
uint8_t *rt = NULL;
bool ret = false;
size_t ctl = 0;
size_t ptl = 0;
size_t rtl = 0;
size_t ttl = 0;
int pad = 0;
switch (str2enum(alg->name, NAMES, NULL)) {
case 0: pad = RSA_PKCS1_PADDING; md = EVP_sha1(); break;
case 1: pad = RSA_PKCS1_OAEP_PADDING; md = EVP_sha1(); break;
case 2: pad = RSA_PKCS1_OAEP_PADDING; md = EVP_sha256(); break;
default: return false;
}
key = jose_openssl_jwk_to_EVP_PKEY(cfg, jwk);
if (!key || EVP_PKEY_base_id(key) != EVP_PKEY_RSA)
goto egress;
ctl = jose_b64_dec(json_object_get(rcp, "encrypted_key"), NULL, 0);
if (ctl == SIZE_MAX)
goto egress;
ct = malloc(ctl);
if (!ct)
goto egress;
if (jose_b64_dec(json_object_get(rcp, "encrypted_key"), ct, ctl) != ctl)
goto egress;
ptl = ctl;
pt = malloc(ptl);
if (!pt)
goto egress;
epc = EVP_PKEY_CTX_new(key, NULL);
if (!epc)
goto egress;
if (EVP_PKEY_decrypt_init(epc) <= 0)
goto egress;
if (EVP_PKEY_CTX_set_rsa_padding(epc, pad) <= 0)
goto egress;
if (pad == RSA_PKCS1_OAEP_PADDING) {
if (EVP_PKEY_CTX_set_rsa_oaep_md(epc, md) <= 0)
return false;
if (EVP_PKEY_CTX_set_rsa_mgf1_md(epc, md) <= 0)
goto egress;
}
/* Handle MMA Attack as prescribed by RFC 3218, always generate a
* random buffer of appropriate length so that the same operations
* are performed whether decrypt succeeds or not, in an attempt to
* foil timing attacks */
rtl = ptl;
rt = malloc(rtl);
if (!rt)
goto egress;
if (RAND_bytes(rt, rtl) <= 0)
goto egress;
ret |= EVP_PKEY_decrypt(epc, pt, &ptl, ct, ctl) > 0;
ttl = ret ? ptl : rtl;
tt = ret ? pt : rt;
ret |= pad == RSA_PKCS1_PADDING;
if (json_object_set_new(cek, "k", jose_b64_enc(tt, ttl)) < 0)
ret = false;
egress:
if (pt) {
OPENSSL_cleanse(pt, ptl);
free(pt);
}
if (rt) {
OPENSSL_cleanse(rt, rtl);
free(rt);
}
free(ct);
return ret;
}
EXPORT_DEF int dc_dtmf_str2setting(const char * value)
{
return str2enum(value, dtmf_values, ITEMS_OF(dtmf_values));
}
int
get_sort_field_enum (const char *str)
{
return str2enum (FIELD, ARRAY_SIZE (FIELD), str);
}
static bool
alg_wrap_unw(const jose_hook_alg_t *alg, jose_cfg_t *cfg, const json_t *jwe,
const json_t *rcp, const json_t *jwk, json_t *cek)
{
const EVP_CIPHER *cph = NULL;
EVP_CIPHER_CTX *ecc = NULL;
bool ret = false;
size_t ctl = 0;
size_t ptl = 0;
int len = 0;
switch (str2enum(alg->name, NAMES, NULL)) {
case 0: cph = EVP_aes_128_wrap(); break;
case 1: cph = EVP_aes_192_wrap(); break;
case 2: cph = EVP_aes_256_wrap(); break;
default: return NULL;
}
uint8_t ky[EVP_CIPHER_key_length(cph)];
uint8_t iv[EVP_CIPHER_iv_length(cph)];
uint8_t ct[KEYMAX + EVP_CIPHER_block_size(cph) * 2];
uint8_t pt[sizeof(ct)];
memset(iv, 0xA6, sizeof(iv));
if (jose_b64_dec(json_object_get(jwk, "k"), NULL, 0) != sizeof(ky))
goto egress;
if (jose_b64_dec(json_object_get(jwk, "k"), ky, sizeof(ky)) != sizeof(ky))
goto egress;
ctl = jose_b64_dec(json_object_get(rcp, "encrypted_key"), NULL, 0);
if (ctl > sizeof(ct))
goto egress;
if (jose_b64_dec(json_object_get(rcp, "encrypted_key"), ct, ctl) != ctl)
goto egress;
ecc = EVP_CIPHER_CTX_new();
if (!ecc)
goto egress;
EVP_CIPHER_CTX_set_flags(ecc, EVP_CIPHER_CTX_FLAG_WRAP_ALLOW);
if (EVP_DecryptInit_ex(ecc, cph, NULL, ky, iv) <= 0)
goto egress;
if (EVP_DecryptUpdate(ecc, pt, &len, ct, ctl) <= 0)
goto egress;
ptl = len;
if (EVP_DecryptFinal(ecc, &pt[len], &len) <= 0)
goto egress;
ptl += len;
ret = json_object_set_new(cek, "k", jose_b64_enc(pt, ptl)) == 0;
egress:
OPENSSL_cleanse(ky, sizeof(ky));
OPENSSL_cleanse(pt, sizeof(pt));
EVP_CIPHER_CTX_free(ecc);
return ret;
}
static json_t *
derive(const jose_hook_alg_t *alg, jose_cfg_t *cfg,
json_t *hdr, json_t *cek, const json_t *key)
{
const jose_hook_alg_t *halg = NULL;
const char *name = alg->name;
uint8_t pu[KEYMAX] = {};
uint8_t pv[KEYMAX] = {};
uint8_t dk[KEYMAX] = {};
uint8_t ky[KEYMAX] = {};
const char *enc = NULL;
json_t *out = NULL;
size_t dkl = 0;
size_t pul = 0;
size_t pvl = 0;
size_t kyl = 0;
halg = jose_hook_alg_find(JOSE_HOOK_ALG_KIND_HASH, "S256");
if (!halg)
goto egress;
if (json_unpack(hdr, "{s?s}", "enc", &enc) < 0)
goto egress;
if (!enc && json_unpack(cek, "{s:s}", "alg", &enc) < 0)
goto egress;
switch (str2enum(alg->name, NAMES, NULL)) {
case 0: dkl = encr_alg_keylen(cfg, enc); name = enc; break;
case 1: dkl = 16; break;
case 2: dkl = 24; break;
case 3: dkl = 32; break;
default:
goto egress;
}
if (dkl < 16 || dkl > sizeof(dk))
goto egress;
pul = decode(hdr, "apu", pu, sizeof(pu));
if (pul > sizeof(pu))
goto egress;
pvl = decode(hdr, "apv", pv, sizeof(pv));
if (pvl > sizeof(pv))
goto egress;
kyl = decode(key, "x", ky, sizeof(ky));
if (kyl > sizeof(ky))
goto egress;
if (!concatkdf(halg, cfg,
dk, dkl,
ky, kyl,
name, strlen(name),
pu, pul,
pv, pvl,
NULL))
goto egress;
out = json_pack("{s:s,s:s,s:o}", "kty", "oct", "alg", enc,
"k", jose_b64_enc(dk, dkl));
egress:
OPENSSL_cleanse(ky, sizeof(ky));
OPENSSL_cleanse(pu, sizeof(pu));
OPENSSL_cleanse(pv, sizeof(pv));
OPENSSL_cleanse(dk, sizeof(dk));
return out;
}
/* first set default values */
memset(config, 0, sizeof(*config));
ast_copy_string (config->context, "default", sizeof (config->context));
ast_copy_string (config->exten, "", sizeof (config->exten));
ast_copy_string (config->language, DEFAULT_LANGUAGE, sizeof (config->language));
config->u2diag = -1;
config->resetdongle = 1;
config->callingpres = -1;
config->initstate = DEV_STATE_STARTED;
config->callwaiting = CALL_WAITING_AUTO;
config->dtmf = DC_DTMF_SETTING_RELAX;
config->mindtmfgap = DEFAULT_MINDTMFGAP;
config->mindtmfduration = DEFAULT_MINDTMFDURATION;
config->mindtmfinterval = DEFAULT_MINDTMFINTERVAL;
}
#/* */
EXPORT_DEF void dc_sconfig_fill(struct ast_config * cfg, const char * cat, struct dc_sconfig * config)
{
struct ast_variable * v;
/* read config and translate to values */
for (v = ast_variable_browse (cfg, cat); v; v = v->next)
{
if (!strcasecmp (v->name, "context"))
{
ast_copy_string (config->context, v->value, sizeof (config->context));
}
else if (!strcasecmp (v->name, "exten"))
{
ast_copy_string (config->exten, v->value, sizeof (config->exten));
}
else if (!strcasecmp (v->name, "language"))
{
ast_copy_string (config->language, v->value, sizeof (config->language));/* set channel language */
}
else if (!strcasecmp (v->name, "group"))
{
config->group = (int) strtol (v->value, (char**) NULL, 10); /* group is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "rxgain"))
{
config->rxgain = (int) strtol (v->value, (char**) NULL, 10); /* rxgain is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "txgain"))
{
config->txgain = (int) strtol (v->value, (char**) NULL, 10); /* txgain is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "u2diag"))
{
errno = 0;
config->u2diag = (int) strtol (v->value, (char**) NULL, 10); /* u2diag is set to -1 if invalid */
if (config->u2diag == 0 && errno == EINVAL)
{
config->u2diag = -1;
}
}
else if (!strcasecmp (v->name, "callingpres"))
{
config->callingpres = ast_parse_caller_presentation (v->value);
if (config->callingpres == -1)
{
errno = 0;
config->callingpres = (int) strtol (v->value, (char**) NULL, 10);/* callingpres is set to -1 if invalid */
if (config->callingpres == 0 && errno == EINVAL)
{
config->callingpres = -1;
}
}
}
else if (!strcasecmp (v->name, "usecallingpres"))
{
config->usecallingpres = ast_true (v->value); /* usecallingpres is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "autodeletesms"))
{
config->autodeletesms = ast_true (v->value); /* autodeletesms is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "resetdongle"))
{
config->resetdongle = ast_true (v->value); /* resetdongle is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "disablesms"))
{
config->disablesms = ast_true (v->value); /* disablesms is set to 0 if invalid */
}
else if (!strcasecmp (v->name, "smsaspdu"))
{
config->smsaspdu = ast_true (v->value); /* send_sms_as_pdu us set to 0 if invalid */
}
else if (!strcasecmp (v->name, "disable"))
{
config->initstate = ast_true (v->value) ? DEV_STATE_REMOVED : DEV_STATE_STARTED;
}
else if (!strcasecmp (v->name, "initstate"))
{
int val = str2enum(v->value, dev_state_strs, ITEMS_OF(dev_state_strs));
if(val == DEV_STATE_STOPPED || val == DEV_STATE_STARTED || val == DEV_STATE_REMOVED)
config->initstate = val;
else
ast_log(LOG_ERROR, "Invalid value for 'initstate': '%s', must be one of 'stop' 'start' 'remove' default is 'start'\n", v->value);
}
else if (!strcasecmp (v->name, "callwaiting"))
{
if(strcasecmp(v->value, "auto"))
config->callwaiting = ast_true (v->value);
}
else if (!strcasecmp (v->name, "dtmf"))
{
int val = dc_dtmf_str2setting(v->value);
if(val >= 0)
config->dtmf = val;
else
ast_log(LOG_ERROR, "Invalid value for 'dtmf': '%s', setting default 'relax'\n", v->value);
}
else if (!strcasecmp (v->name, "mindtmfgap"))
{
errno = 0;
config->mindtmfgap = (int) strtol (v->value, (char**) NULL, 10);
if ((config->mindtmfgap == 0 && errno == EINVAL) || config->mindtmfgap < 0)
{
ast_log(LOG_ERROR, "Invalid value for 'mindtmfgap' '%s', setting default %d\n", v->value, DEFAULT_MINDTMFGAP);
config->mindtmfgap = DEFAULT_MINDTMFGAP;
}
}
else if (!strcasecmp (v->name, "mindtmfduration"))
{
errno = 0;
config->mindtmfduration = (int) strtol (v->value, (char**) NULL, 10);
if ((config->mindtmfduration == 0 && errno == EINVAL) || config->mindtmfduration < 0)
{
ast_log(LOG_ERROR, "Invalid value for 'mindtmfgap' '%s', setting default %d\n", v->value, DEFAULT_MINDTMFDURATION);
config->mindtmfduration = DEFAULT_MINDTMFDURATION;
}
}
else if (!strcasecmp (v->name, "mindtmfinterval"))
{
errno = 0;
config->mindtmfinterval = (int) strtol (v->value, (char**) NULL, 10);
if ((config->mindtmfinterval == 0 && errno == EINVAL) || config->mindtmfinterval < 0)
{
ast_log(LOG_ERROR, "Invalid value for 'mindtmfinterval' '%s', setting default %d\n", v->value, DEFAULT_MINDTMFINTERVAL);
config->mindtmfduration = DEFAULT_MINDTMFINTERVAL;
}
}
}
}
