/*
* build attributeCertificateInfo
*/
static chunk_t
build_attr_cert_info(void)
{
return asn1_wrap(ASN1_SEQUENCE, "cmmcmmmm"
, ASN1_INTEGER_1
, build_holder()
, build_v2_form()
, ASN1_sha1WithRSA_id
, asn1_simple_object(ASN1_INTEGER, serial)
, build_attr_cert_validity()
, build_attributes()
, build_extensions());
}
/* Build a value tree from the already stored values. */
static gpg_error_t
build_cri (ksba_certreq_t cr)
{
gpg_error_t err;
ksba_writer_t writer;
void *value = NULL;
size_t valuelen;
int certmode;
/* If a serial number has been set, we don't create a CSR but a
proper certificate. */
certmode = !!cr->x509.serial.der;
err = ksba_writer_new (&writer);
if (err)
goto leave;
err = ksba_writer_set_mem (writer, 2048);
if (err)
goto leave;
if (!cr->key.der)
{
err = gpg_error (GPG_ERR_MISSING_VALUE);
goto leave;
}
/* We write all stuff out to a temporary writer object, then use
this object to create the cri and store the cri image */
if (certmode)
{
/* Store the version structure; version is 3 (encoded as 2):
[0] { INTEGER 2 } */
err = ksba_writer_write (writer, "\xa0\x03\x02\x01\x02", 5);
}
else
{
/* Store version v1 (which is a 0). */
err = _ksba_ber_write_tl (writer, TYPE_INTEGER, CLASS_UNIVERSAL, 0, 1);
if (!err)
err = ksba_writer_write (writer, "", 1);
}
if (err)
goto leave;
/* For a certificate we need to store the s/n, the signature
algorithm identifier, the issuer DN and the validity. */
if (certmode)
{
/* Store the serial number. */
err = _ksba_ber_write_tl (writer, TYPE_INTEGER, CLASS_UNIVERSAL, 0,
cr->x509.serial.derlen);
if (!err)
err = ksba_writer_write (writer,
cr->x509.serial.der, cr->x509.serial.derlen);
if (err)
goto leave;
/* Store the signature algorithm identifier. */
if (!cr->x509.siginfo.der)
err = gpg_error (GPG_ERR_MISSING_VALUE);
else
err = ksba_writer_write (writer,
cr->x509.siginfo.der, cr->x509.siginfo.derlen);
if (err)
goto leave;
/* Store the issuer DN. If no issuer DN has been set we use the
subject DN. */
if (cr->x509.issuer.der)
err = ksba_writer_write (writer,
cr->x509.issuer.der, cr->x509.issuer.derlen);
else if (cr->subject.der)
err = ksba_writer_write (writer, cr->subject.der, cr->subject.derlen);
else
err = gpg_error (GPG_ERR_MISSING_VALUE);
if (err)
goto leave;
/* Store the Validity. */
{
unsigned char templ[36];
unsigned char *tp;
tp = templ;
*tp++ = 0x30;
*tp++ = 0x22;
*tp++ = TYPE_GENERALIZED_TIME;
*tp++ = 15;
if (cr->x509.not_before[0])
{
if (_ksba_cmp_time (cr->x509.not_before, "20500101T000000") >= 0)
{
memcpy (tp, cr->x509.not_before, 8);
tp += 8;
memcpy (tp, cr->x509.not_before+9, 6);
tp += 6;
}
else
{
tp[-2] = TYPE_UTC_TIME;
tp[-1] = 13;
memcpy (tp, cr->x509.not_before+2, 6);
tp += 6;
memcpy (tp, cr->x509.not_before+9, 6);
tp += 6;
}
}
else
{
tp[-2] = TYPE_UTC_TIME;
tp[-1] = 13;
memcpy (tp, "110101000000", 12);
tp += 12;
}
*tp++ = 'Z';
*tp++ = TYPE_GENERALIZED_TIME;
*tp++ = 15;
if (cr->x509.not_after[0])
{
if (_ksba_cmp_time (cr->x509.not_after, "20500101T000000") >= 0)
{
memcpy (tp, cr->x509.not_after, 8);
tp += 8;
memcpy (tp, cr->x509.not_after+9, 6);
tp += 6;
}
else
{
tp[-2] = TYPE_UTC_TIME;
tp[-1] = 13;
memcpy (tp, cr->x509.not_after+2, 6);
tp += 6;
memcpy (tp, cr->x509.not_after+9, 6);
tp += 6;
}
}
else
{
memcpy (tp,"20630405170000", 14);
tp += 14;
}
*tp++ = 'Z';
assert (tp - templ <= 36);
templ[1] = tp - templ - 2; /* Fixup the sequence length. */
err = ksba_writer_write (writer, templ, tp - templ);
if (err)
goto leave;
}
}
/* store the subject */
if (!cr->subject.der)
{
err = gpg_error (GPG_ERR_MISSING_VALUE);
goto leave;
}
err = ksba_writer_write (writer, cr->subject.der, cr->subject.derlen);
if (err)
goto leave;
/* store the public key info */
err = ksba_writer_write (writer, cr->key.der, cr->key.derlen);
if (err)
goto leave;
/* Copy generalNames objects to the extension list. */
if (cr->subject_alt_names)
{
err = add_general_names_to_extn (cr, cr->subject_alt_names,
oidstr_subjectAltName);
if (err)
goto leave;
while (cr->subject_alt_names)
{
struct general_names_s *tmp = cr->subject_alt_names->next;
xfree (cr->subject_alt_names);
cr->subject_alt_names = tmp;
}
cr->subject_alt_names = NULL;
}
/* Write the extensions. Note that the implicit SET OF is REQUIRED */
xfree (value); value = NULL;
valuelen = 0;
if (cr->extn_list)
{
err = build_extensions (cr, certmode, &value, &valuelen);
if (err)
goto leave;
err = _ksba_ber_write_tl (writer, certmode? 3:0,
CLASS_CONTEXT, 1, valuelen);
if (!err)
err = ksba_writer_write (writer, value, valuelen);
if (err)
goto leave;
}
else
{ /* We can't write an object of length zero using our ber_write
function. So we must open encode it. */
err = ksba_writer_write (writer,
certmode? "\xa3\x02\x30":"\xa0\x02\x30", 4);
if (err)
goto leave;
}
/* pack it into the sequence */
xfree (value);
value = ksba_writer_snatch_mem (writer, &valuelen);
if (!value)
{
err = gpg_error (GPG_ERR_ENOMEM);
goto leave;
}
/* reinitialize the buffer to create the outer sequence */
err = ksba_writer_set_mem (writer, valuelen+10);
if (err)
goto leave;
/* write outer sequence */
err = _ksba_ber_write_tl (writer, TYPE_SEQUENCE, CLASS_UNIVERSAL,
1, valuelen);
if (!err)
err = ksba_writer_write (writer, value, valuelen);
if (err)
goto leave;
/* and store the final result */
cr->cri.der = ksba_writer_snatch_mem (writer, &cr->cri.derlen);
if (!cr->cri.der)
err = gpg_error (GPG_ERR_ENOMEM);
leave:
ksba_writer_release (writer);
xfree (value);
return err;
}
void
check_opengl_features(void)
{
GL_vendor = xstrdup((char*)gl(GetString, GL_VENDOR));
GL_renderer = xstrdup((char*)gl(GetString, GL_RENDERER));
GL_version = xstrdup((char*)gl(GetString, GL_VERSION));
/* according to opengl spec, the version string of opengl and
* glsl is
*
* <version number> <space> <vendor spec information>
*
* and <version number> is
*
* major.minor
*
* or
*
* major.minor.release
*
* */
/* build gl version */
int err;
err = sscanf(GL_version, "%d.%d", &GL_major_version, &GL_minor_version);
assert(err == 2);
assert((GL_major_version > 0) && (GL_major_version <= 3));
assert(GL_minor_version > 0);
GL_full_version = MKVER(GL_major_version, GL_minor_version);
const char * tmp = (const char *)gl(GetString, GL_SHADING_LANGUAGE_VERSION);
if (GL_POP_ERROR() != GL_NO_ERROR) {
WARNING(OPENGL, "Doesn't support glsl\n");
GL_glsl_version = NULL;
} else {
GL_glsl_version = xstrdup(tmp);
err = sscanf(GL_glsl_version, "%d.%d", &GLSL_major_version, &GLSL_minor_version);
assert(err == 2);
assert(GLSL_major_version > 0);
assert(GLSL_minor_version > 0);
GLSL_full_version = MKVER(GLSL_major_version, GLSL_minor_version);
}
VERBOSE(OPENGL, "OpenGL engine information:\n");
VERBOSE(OPENGL, "\tvendor: %s\n", GL_vendor);
VERBOSE(OPENGL, "\trenderer: %s\n", GL_renderer);
VERBOSE(OPENGL, "\tversion: %s\n", GL_version);
VERBOSE(OPENGL, "\tglsl version: %s\n", GL_glsl_version);
int x;
gl(GetIntegerv, GL_SAMPLES, &x);
VERBOSE(OPENGL, "\tSamples : %d\n", x);
gl(GetIntegerv, GL_SAMPLE_BUFFERS, &x);
VERBOSE(OPENGL, "\tSample buffers : %d\n", x);
if (x > 0)
gl(Enable, GL_MULTISAMPLE);
if (GL_POP_ERROR())
WARNING(OPENGL, "platform does not support multisample\n");
gl(GetIntegerv, GL_MAX_TEXTURE_SIZE, &GL_max_texture_size);
DEBUG(OPENGL, "system max texture size: %d\n", GL_max_texture_size);
int conf_mts = conf_get_int("video.opengl.texture.maxsize", 0);
if (conf_mts != 0) {
conf_mts = pow2roundup(conf_mts);
if (conf_mts < GL_max_texture_size)
GL_max_texture_size = conf_mts;
}
DEBUG(OPENGL, "max texture size is set to %d\n", GL_max_texture_size);
gl(GetIntegerv, GL_MAX_VERTEX_ATTRIBS, &GL_max_vertex_attribs);
DEBUG(OPENGL, "max vertex attributes is set to %d\n", GL_max_vertex_attribs);
build_extensions();
assert(GL_extensions_dict != NULL);
GL_POP_ERROR();
#define verbose_feature(name, exp) do {\
if (exp) \
DEBUG(OPENGL, name " is enabled\n"); \
else \
DEBUG(OPENGL, name " is disabled\n"); \
} while(0)
GL_texture_NPOT = check_extension("video.opengl.texture.enableNPOT",
"GL_ARB_texture_non_power_of_two",
NULL);
verbose_feature("NPOT texture", GL_texture_NPOT);
GL_texture_RECT = check_extension("video.opengl.texture.enableRECT",
"GL_ARB_texture_rectangle",
"GL_EXT_texture_rectangle",
"GL_NV_texture_rectangle",
NULL);
verbose_feature("RECT texture", GL_texture_RECT);
GL_texture_COMPRESSION = check_extension("video.opengl.texture.enableCOMPRESSION",
"GL_ARB_texture_compression",
NULL);
verbose_feature("texture compression", GL_texture_COMPRESSION);
GL_vertex_buffer_object = check_extension("video.opengl.enableVBO",
"GL_ARB_vertex_buffer_object",
NULL);
GL_pixel_buffer_object = check_extension("video.opengl.enablePBO",
"GL_ARB_pixel_buffer_object",
NULL);
GL_vertex_array_object = check_extension("video.opengl.enableVAO",
"GL_ARB_vertex_array_object",
NULL);
#undef verbose_feature
}
/* Build a value tree from the already stored values. */
static gpg_error_t
build_cri (ksba_certreq_t cr)
{
gpg_error_t err;
ksba_writer_t writer;
void *value = NULL;
size_t valuelen;
err = ksba_writer_new (&writer);
if (err)
goto leave;
err = ksba_writer_set_mem (writer, 2048);
if (err)
goto leave;
/* We write all stuff out to a temporary writer object, then use
this object to create the cri and store the cri image */
/* store version v1 (which is a 0) */
err = _ksba_ber_write_tl (writer, TYPE_INTEGER, CLASS_UNIVERSAL, 0, 1);
if (!err)
err = ksba_writer_write (writer, "", 1);
if (err)
goto leave;
/* store the subject */
if (!cr->subject.der)
{
err = gpg_error (GPG_ERR_MISSING_VALUE);
goto leave;
}
err = ksba_writer_write (writer, cr->subject.der, cr->subject.derlen);
if (err)
goto leave;
/* store the public key info */
if (!cr->key.der)
{
err = gpg_error (GPG_ERR_MISSING_VALUE);
goto leave;
}
err = ksba_writer_write (writer, cr->key.der, cr->key.derlen);
if (err)
goto leave;
/* Copy generalNames objects to the extension list. */
if (cr->subject_alt_names)
{
err = add_general_names_to_extn (cr, cr->subject_alt_names,
oidstr_subjectAltName);
if (err)
goto leave;
while (cr->subject_alt_names)
{
struct general_names_s *tmp = cr->subject_alt_names->next;
xfree (cr->subject_alt_names);
cr->subject_alt_names = tmp;
}
cr->subject_alt_names = NULL;
}
/* Write the extensions. Note that the implicit SET OF is REQUIRED */
xfree (value); value = NULL;
valuelen = 0;
if (cr->extn_list)
{
err = build_extensions (cr, &value, &valuelen);
if (err)
goto leave;
err = _ksba_ber_write_tl (writer, 0, CLASS_CONTEXT, 1, valuelen);
if (!err)
err = ksba_writer_write (writer, value, valuelen);
if (err)
goto leave;
}
else
{ /* We can't write an object of length zero using our ber_write
function. So we must open encode it. */
err = ksba_writer_write (writer, "\xa0\x02\x30", 4);
if (err)
goto leave;
}
/* pack it into the sequence */
xfree (value);
value = ksba_writer_snatch_mem (writer, &valuelen);
if (!value)
{
err = gpg_error (GPG_ERR_ENOMEM);
goto leave;
}
/* reinitialize the buffer to create the outer sequence */
err = ksba_writer_set_mem (writer, valuelen+10);
if (err)
goto leave;
/* write outer sequence */
err = _ksba_ber_write_tl (writer, TYPE_SEQUENCE, CLASS_UNIVERSAL,
1, valuelen);
if (!err)
err = ksba_writer_write (writer, value, valuelen);
if (err)
goto leave;
/* and store the final result */
cr->cri.der = ksba_writer_snatch_mem (writer, &cr->cri.derlen);
if (!cr->cri.der)
err = gpg_error (GPG_ERR_ENOMEM);
leave:
ksba_writer_release (writer);
xfree (value);
return err;
}
