/* tagged strings/object/XXX */
#define heim_base_is_tagged(x) (((uintptr_t)(x)) & 0x3)
-#define heim_base_is_tagged_string(x) ((((uintptr_t)(x)) & 0x3) == 2)
-#define heim_base_make_tagged_string_ptr(x) ((heim_object_t)(((uintptr_t)(x)) | 2))
-#define heim_base_tagged_string_ptr(x) ((char *)(((uintptr_t)(x)) & (~3)))
-
-
#define heim_base_is_tagged_object(x) ((((uintptr_t)(x)) & 0x3) == 1)
#define heim_base_make_tagged_object(x, tid) \
((heim_object_t)((((uintptr_t)(x)) << 5) | ((tid) << 2) | 0x1))
if (heim_base_is_tagged(ptr)) {
if (heim_base_is_tagged_object(ptr))
return tagged_isa[heim_base_tagged_object_tid(ptr)];
- if (heim_base_is_tagged_string(ptr))
- return &_heim_string_object;
heim_abort("not a supported tagged type");
}
p = PTR2BASE(ptr);
typedef struct heim_string_data *heim_string_t;
heim_string_t heim_string_create(const char *);
-heim_string_t heim_string_create_with_static(const char *);
heim_tid_t heim_string_get_type_id(void);
const char * heim_string_get_utf8(heim_string_t);
static int
string_cmp(void *a, void *b)
{
- if (heim_base_is_tagged_string(a))
- a = heim_base_tagged_string_ptr(a);
- if (heim_base_is_tagged_string(b))
- b = heim_base_tagged_string_ptr(b);
-
return strcmp(a, b);
}
static unsigned long
string_hash(void *ptr)
{
- const char *s;
+ const char *s = ptr;
unsigned long n;
- if (heim_base_is_tagged_string(ptr))
- s = heim_base_tagged_string_ptr(ptr);
- else
- s = ptr;
-
for (n = 0; *s; ++s)
n += *s;
return n;
}
-
struct heim_type_data _heim_string_object = {
HEIM_TID_STRING,
"string-object",
return s;
}
-/**
- * Create a string object from a strings allocated in the text segment.
- *
- * Note that static string object wont be auto released with
- * heim_auto_release(), the allocation policy of the string must
- * be manged separately from the returned object. This make this
- * function not very useful for strings in allocated from heap or
- * stack. In that case you should use heim_string_create().
- *
- * @param string the string to create, must be an utf8 string
- *
- * @return string object
- */
-
-heim_string_t
-heim_string_create_with_static(const char *string)
-{
- return heim_base_make_tagged_string_ptr(string);
-}
-
/**
* Return the type ID of string objects
*
heim_auto_release_create;
heim_auto_release_drain;
heim_base_once_f;
+ heim_cmp;
heim_dict_add_value;
heim_dict_copy_value;
heim_dict_create;
heim_string_create;
heim_string_get_utf8;
heim_number_create;
- heim_string_create_with_static;
local:
*;
};
krb5_kdc_save_request;
krb5_kdc_update_time;
krb5_kdc_pk_initialize;
+
+ # needed for digest-service
+ _kdc_db_fetch;
+ _kdc_free_ent;
local:
*;
};
continue;
}
if(c == '\n'){
- lex_error_message("unterminated string");
+ _lex_error_message("unterminated string");
lineno++;
break;
}
}
void
-lex_error_message (const char *format, ...)
+_lex_error_message (const char *format, ...)
{
va_list args;
/* $Id$ */
-void lex_error_message (const char *, ...)
+void _lex_error_message (const char *, ...)
__attribute__ ((format (printf, 1, 2)));
int yylex(void);
continue;
}
if(c == '\n'){
- lex_error_message("unterminated string");
+ _lex_error_message("unterminated string");
lineno++;
break;
}
}
void
-lex_error_message (const char *format, ...)
+_lex_error_message (const char *format, ...)
{
va_list args;
void
yyerror (char *s)
{
- lex_error_message ("%s\n", s);
+ _lex_error_message ("%s\n", s);
}
#line 296 ""
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
void
yyerror (char *s)
{
- lex_error_message ("%s\n", s);
+ _lex_error_message ("%s\n", s);
}
#define GSS_IOV_BUFFER_TYPE_STREAM 10
#define GSS_IOV_BUFFER_TYPE_SIGN_ONLY 11
-#define GSS_IOV_BUFFER_TYPE_FLAG_MASK 0xffff0000
-#define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATE 0x00010000
-#define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED 0x00020000
+#define GSS_IOV_BUFFER_TYPE_FLAG_MASK 0xffff0000
+#define GSS_IOV_BUFFER_FLAG_ALLOCATE 0x00010000
+#define GSS_IOV_BUFFER_FLAG_ALLOCATED 0x00020000
+
+#define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATE 0x00010000 /* old name */
+#define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED 0x00020000 /* old name */
#define GSS_IOV_BUFFER_TYPE(_t) ((_t) & ~GSS_IOV_BUFFER_TYPE_FLAG_MASK)
#define GSS_IOV_BUFFER_FLAGS(_t) ((_t) & GSS_IOV_BUFFER_TYPE_FLAG_MASK)
OM_uint32
_gk_allocate_buffer(OM_uint32 *minor_status, gss_iov_buffer_desc *buffer, size_t size)
{
- if (buffer->type & GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED) {
+ if (buffer->type & GSS_IOV_BUFFER_FLAG_ALLOCATED) {
if (buffer->buffer.length == size)
return GSS_S_COMPLETE;
free(buffer->buffer.value);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
- buffer->type |= GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED;
+ buffer->type |= GSS_IOV_BUFFER_FLAG_ALLOCATED;
return GSS_S_COMPLETE;
}
rrc -= ec;
gsshsize += gsstsize;
gsstsize = 0;
- } else if (GSS_IOV_BUFFER_FLAGS(trailer->type) & GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATE) {
+ } else if (GSS_IOV_BUFFER_FLAGS(trailer->type) & GSS_IOV_BUFFER_FLAG_ALLOCATE) {
major_status = _gk_allocate_buffer(minor_status, trailer, gsstsize);
if (major_status)
goto failure;
*
*/
- if (GSS_IOV_BUFFER_FLAGS(header->type) & GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATE) {
+ if (GSS_IOV_BUFFER_FLAGS(header->type) & GSS_IOV_BUFFER_FLAG_ALLOCATE) {
major_status = _gk_allocate_buffer(minor_status, header, gsshsize);
if (major_status != GSS_S_COMPLETE)
goto failure;
case GSS_C_GSS_CODE: {
if (value != mg->maj_stat || mg->maj_error.length == 0)
break;
- string->value = malloc(mg->maj_error.length);
+ string->value = malloc(mg->maj_error.length + 1);
string->length = mg->maj_error.length;
memcpy(string->value, mg->maj_error.value, mg->maj_error.length);
+ ((char *) string->value)[string->length] = '\0';
return GSS_S_COMPLETE;
}
case GSS_C_MECH_CODE: {
if (value != mg->min_stat || mg->min_error.length == 0)
break;
- string->value = malloc(mg->min_error.length);
+ string->value = malloc(mg->min_error.length + 1);
string->length = mg->min_error.length;
memcpy(string->value, mg->min_error.value, mg->min_error.length);
+ ((char *) string->value)[string->length] = '\0';
return GSS_S_COMPLETE;
}
}
*/
struct _gss_mechanism_cred {
- SLIST_ENTRY(_gss_mechanism_cred) gmc_link;
+ HEIM_SLIST_ENTRY(_gss_mechanism_cred) gmc_link;
gssapi_mech_interface gmc_mech; /* mechanism ops for MC */
gss_OID gmc_mech_oid; /* mechanism oid for MC */
gss_cred_id_t gmc_cred; /* underlying MC */
};
-SLIST_HEAD(_gss_mechanism_cred_list, _gss_mechanism_cred);
+HEIM_SLIST_HEAD(_gss_mechanism_cred_list, _gss_mechanism_cred);
struct _gss_cred {
struct _gss_mechanism_cred_list gc_mc;
}
if (cred) {
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link)
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link)
if (mc->gmc_mech == m)
break;
if (!mc) {
gss_delete_sec_context(&junk, context_handle, NULL);
return (GSS_S_FAILURE);
}
- SLIST_INIT(&dcred->gc_mc);
+ HEIM_SLIST_INIT(&dcred->gc_mc);
dmc = malloc(sizeof(struct _gss_mechanism_cred));
if (!dmc) {
free(dcred);
dmc->gmc_mech = m;
dmc->gmc_mech_oid = &m->gm_mech_oid;
dmc->gmc_cred = delegated_mc;
- SLIST_INSERT_HEAD(&dcred->gc_mc, dmc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&dcred->gc_mc, dmc, gmc_link);
*delegated_cred_handle = (gss_cred_id_t) dcred;
}
*minor_status = ENOMEM;
return (GSS_S_FAILURE);
}
- SLIST_INIT(&cred->gc_mc);
+ HEIM_SLIST_INIT(&cred->gc_mc);
if (mechs == GSS_C_NO_OID_SET)
mechs = _gss_mech_oids;
}
}
- SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
}
/*
* If we didn't manage to create a single credential, return
* an error.
*/
- if (!SLIST_FIRST(&cred->gc_mc)) {
+ if (!HEIM_SLIST_FIRST(&cred->gc_mc)) {
free(cred);
if (actual_mechs)
gss_release_oid_set(minor_status, actual_mechs);
*minor_status = ENOMEM;
return (GSS_S_FAILURE);
}
- SLIST_INIT(&new_cred->gc_mc);
+ HEIM_SLIST_INIT(&new_cred->gc_mc);
/*
* We go through all the mc attached to the input_cred_handle
*/
target_mc = 0;
if (cred) {
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
if (gss_oid_equal(mc->gmc_mech_oid, desired_mech)) {
target_mc = mc;
}
*minor_status = ENOMEM;
return (GSS_S_FAILURE);
}
- SLIST_INSERT_HEAD(&new_cred->gc_mc, copy_mc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&new_cred->gc_mc, copy_mc, gmc_link);
}
}
free(mc);
return (major_status);
}
- SLIST_INSERT_HEAD(&new_cred->gc_mc, mc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&new_cred->gc_mc, mc, gmc_link);
*output_cred_handle = (gss_cred_id_t) new_cred;
return (GSS_S_COMPLETE);
/**
* Free all buffer allocated by gss_wrap_iov() or gss_unwrap_iov() by
- * looking at the GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED flag.
+ * looking at the GSS_IOV_BUFFER_FLAG_ALLOCATED flag.
*
* @ingroup gssapi
*/
return GSS_S_CALL_INACCESSIBLE_READ;
for (i = 0; i < iov_count; i++) {
- if ((iov[i].type & GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED) == 0)
+ if ((iov[i].type & GSS_IOV_BUFFER_FLAG_ALLOCATED) == 0)
continue;
gss_release_buffer(&junk, &iov[i].buffer);
- iov[i].type &= ~GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED;
+ iov[i].type &= ~GSS_IOV_BUFFER_FLAG_ALLOCATED;
}
return GSS_S_COMPLETE;
}
return (GSS_S_FAILURE);
}
- SLIST_INIT(&name->gn_mn);
+ HEIM_SLIST_INIT(&name->gn_mn);
mn->gmn_mech = m;
mn->gmn_mech_oid = &m->gm_mech_oid;
mn->gmn_name = new_canonical_name;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
*output_name = (gss_name_t) name;
struct _gss_mechanism_name *mn1;
struct _gss_mechanism_name *mn2;
- SLIST_FOREACH(mn1, &name1->gn_mn, gmn_link) {
+ HEIM_SLIST_FOREACH(mn1, &name1->gn_mn, gmn_link) {
OM_uint32 major_status;
major_status = _gss_find_mn(minor_status, name2,
return GSS_S_NO_CRED;
}
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
if (mc->gmc_mech->gm_export_cred == NULL) {
*minor_status = 0;
return GSS_S_NO_CRED;
return GSS_S_FAILURE;
}
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
major = mc->gmc_mech->gm_export_cred(minor_status,
mc->gmc_cred, &buffer);
*minor_status = ENOMEM;
return GSS_S_FAILURE;
}
- SLIST_INIT(&cred->gc_mc);
+ HEIM_SLIST_INIT(&cred->gc_mc);
*cred_handle = (gss_cred_id_t)cred;
mc->gmc_mech_oid = &m->gm_mech_oid;
mc->gmc_cred = mcred;
- SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
}
krb5_storage_free(sp);
sp = NULL;
- if (SLIST_EMPTY(&cred->gc_mc)) {
+ if (HEIM_SLIST_EMPTY(&cred->gc_mc)) {
major = GSS_S_NO_CRED;
goto out;
}
*minor_status = 0;
return (GSS_S_COMPLETE);
} else {
- SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
+ HEIM_SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
major_status = mn->gmn_mech->gm_display_name(
minor_status, mn->gmn_name,
output_name_buffer,
return (major_status);
new_name = (struct _gss_name *) *dest_name;
- SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
+ HEIM_SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
struct _gss_mechanism_name *mn2;
_gss_find_mn(minor_status, new_name,
mn->gmn_mech_oid, &mn2);
return (GSS_S_FAILURE);
}
memset(new_name, 0, sizeof(struct _gss_name));
- SLIST_INIT(&new_name->gn_mn);
+ HEIM_SLIST_INIT(&new_name->gn_mn);
*dest_name = (gss_name_t) new_name;
- SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
+ HEIM_SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
struct _gss_mechanism_name *new_mn;
new_mn = malloc(sizeof(*new_mn));
free(new_mn);
continue;
}
- SLIST_INSERT_HEAD(&new_name->gn_mn, new_mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&new_name->gn_mn, new_mn, gmn_link);
}
}
* one, otherwise export based on the first mechanism in our
* list.
*/
- mn = SLIST_FIRST(&name->gn_mn);
+ mn = HEIM_SLIST_FIRST(&name->gn_mn);
if (!mn) {
*minor_status = 0;
return (GSS_S_NAME_NOT_MN);
return (GSS_S_FAILURE);
}
- SLIST_INIT(&name->gn_mn);
+ HEIM_SLIST_INIT(&name->gn_mn);
major_status = _gss_copy_oid(minor_status,
name_type, &name->gn_type);
* for those supported this nametype.
*/
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
int present = 0;
major_status = gss_test_oid_set_member(minor_status,
mn->gmn_mech = &m->gm_mech;
mn->gmn_mech_oid = &m->gm_mech_oid;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
}
/*
* If we can't find a mn for the name, bail out already here.
*/
- mn = SLIST_FIRST(&name->gn_mn);
+ mn = HEIM_SLIST_FIRST(&name->gn_mn);
if (!mn) {
*minor_status = 0;
major_status = GSS_S_NAME_NOT_MN;
if (major_status)
return (major_status);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_indicate_mechs) {
major_status = m->gm_mech.gm_indicate_mechs(
minor_status, &set);
if (cred == NULL)
return GSS_C_NO_CREDENTIAL;
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
if (gss_oid_equal(mech_type, mc->gmc_mech_oid))
return mc->gmc_cred;
}
*minor_status = ENOMEM;
return (GSS_S_FAILURE);
}
- SLIST_INIT(&name->gn_mn);
+ HEIM_SLIST_INIT(&name->gn_mn);
} else {
name = NULL;
}
if (cred) {
struct _gss_mechanism_cred *mc;
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
gss_name_t mc_name;
OM_uint32 mc_lifetime;
mn->gmn_mech = mc->gmc_mech;
mn->gmn_mech_oid = mc->gmc_mech_oid;
mn->gmn_name = mc_name;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
} else {
mc->gmc_mech->gm_release_name(minor_status,
&mc_name);
found++;
}
} else {
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
gss_name_t mc_name;
OM_uint32 mc_lifetime;
mn->gmn_mech = &m->gm_mech;
mn->gmn_mech_oid = &m->gm_mech_oid;
mn->gmn_name = mc_name;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
} else if (mc_name) {
m->gm_mech.gm_release_name(minor_status,
&mc_name);
if (cred_handle != GSS_C_NO_CREDENTIAL) {
struct _gss_cred *cred = (struct _gss_cred *) cred_handle;
- SLIST_FOREACH(mcp, &cred->gc_mc, gmc_link)
+ HEIM_SLIST_FOREACH(mcp, &cred->gc_mc, gmc_link)
if (mcp->gmc_mech == m)
break;
if (!mcp)
if (cred == NULL)
return GSS_S_NO_CRED;
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
gss_buffer_set_t rset = GSS_C_NO_BUFFER_SET;
int i;
* name's type is supported by the mechanism. If it is, add
* the mechanism to the set.
*/
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
major_status = gss_inquire_names_for_mech(minor_status,
&m->gm_mech_oid, &name_types);
if (major_status) {
buffer.value = rk_UNCONST(identity);
buffer.length = strlen(identity);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = &b;
buffer.length = sizeof(b);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.length = 0;
}
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = rk_UNCONST(name);
buffer.length = strlen(name);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = rk_UNCONST(realm);
buffer.length = strlen(realm);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = &o;
buffer.length = sizeof(o);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = &o;
buffer.length = sizeof(o);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
maj_stat = m->gm_mech.gm_set_sec_context_option(&junk, NULL,
buffer.value = c;
buffer.length = sizeof(*c);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_sec_context_option == NULL)
continue;
m->gm_mech.gm_set_sec_context_option(&junk, NULL,
if (m->gm_name_types == NULL)
gss_create_empty_oid_set(&minor_status, &m->gm_name_types);
- SLIST_INSERT_HEAD(&_gss_mechs, m, gm_link);
+ HEIM_SLIST_INSERT_HEAD(&_gss_mechs, m, gm_link);
return 0;
}
HEIMDAL_MUTEX_lock(&_gss_mech_mutex);
- if (SLIST_FIRST(&_gss_mechs)) {
+ if (HEIM_SLIST_FIRST(&_gss_mechs)) {
HEIMDAL_MUTEX_unlock(&_gss_mech_mutex);
return;
}
* Check for duplicates, already loaded mechs.
*/
found = 0;
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (gss_oid_equal(&m->gm_mech.gm_mech_oid, &mech_oid)) {
found = 1;
free(mech_oid.elements);
#define RTLD_LOCAL 0
#endif
- so = dlopen(lib, RTLD_LAZY | RTLD_LOCAL);
+#ifndef RTLD_GROUP
+#define RTLD_GROUP 0
+#endif
+
+ so = dlopen(lib, RTLD_LAZY | RTLD_LOCAL | RTLD_GROUP);
if (!so) {
/* fprintf(stderr, "dlopen: %s\n", dlerror()); */
free(mech_oid.elements);
OPTSYM(unwrap_iov);
OPTSYM(wrap_iov_length);
- SLIST_INSERT_HEAD(&_gss_mechs, m, gm_link);
+ HEIM_SLIST_INSERT_HEAD(&_gss_mechs, m, gm_link);
continue;
bad:
struct _gss_mech_switch *m;
_gss_load_mech();
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (gss_oid_equal(&m->gm_mech.gm_mech_oid, mech))
return &m->gm_mech;
}
*mech_type = NULL;
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
major = mo_value(&m->gm_mech_oid, GSS_C_MA_SASL_MECH_NAME, &name);
if (major)
_gss_load_mech();
- SLIST_FOREACH(ms, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(ms, &_gss_mechs, gm_link) {
gssapi_mech_interface mi = &ms->gm_mech;
if (desired_mech_attrs) {
_gss_load_mech();
- SLIST_FOREACH(m, &_gss_mechs, gm_link)
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link)
add_all_mo(&m->gm_mech, known_mech_attrs, GSS_MO_MA);
}
*output_mn = NULL;
- SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
+ HEIM_SLIST_FOREACH(mn, &name->gn_mn, gmn_link) {
if (gss_oid_equal(mech, mn->gmn_mech_oid))
break;
}
mn->gmn_mech = m;
mn->gmn_mech_oid = &m->gm_mech_oid;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
}
*output_mn = mn;
return 0;
return (0);
}
- SLIST_INIT(&name->gn_mn);
+ HEIM_SLIST_INIT(&name->gn_mn);
mn->gmn_mech = m;
mn->gmn_mech_oid = &m->gm_mech_oid;
mn->gmn_name = new_mn;
- SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
+ HEIM_SLIST_INSERT_HEAD(&name->gn_mn, mn, gmn_link);
return (name);
}
if (*cred_handle == GSS_C_NO_CREDENTIAL)
return (GSS_S_COMPLETE);
- while (SLIST_FIRST(&cred->gc_mc)) {
- mc = SLIST_FIRST(&cred->gc_mc);
- SLIST_REMOVE_HEAD(&cred->gc_mc, gmc_link);
+ while (HEIM_SLIST_FIRST(&cred->gc_mc)) {
+ mc = HEIM_SLIST_FIRST(&cred->gc_mc);
+ HEIM_SLIST_REMOVE_HEAD(&cred->gc_mc, gmc_link);
mc->gmc_mech->gm_release_cred(minor_status, &mc->gmc_cred);
free(mc);
}
if (name->gn_type.elements)
free(name->gn_type.elements);
- while (SLIST_FIRST(&name->gn_mn)) {
+ while (HEIM_SLIST_FIRST(&name->gn_mn)) {
struct _gss_mechanism_name *mn;
- mn = SLIST_FIRST(&name->gn_mn);
- SLIST_REMOVE_HEAD(&name->gn_mn, gmn_link);
+ mn = HEIM_SLIST_FIRST(&name->gn_mn);
+ HEIM_SLIST_REMOVE_HEAD(&name->gn_mn, gmn_link);
mn->gmn_mech->gm_release_name(minor_status,
&mn->gmn_name);
free(mn);
if (cred == NULL)
return GSS_S_FAILURE;
- SLIST_INIT(&cred->gc_mc);
+ HEIM_SLIST_INIT(&cred->gc_mc);
- SLIST_FOREACH(m, &_gss_mechs, gm_link) {
+ HEIM_SLIST_FOREACH(m, &_gss_mechs, gm_link) {
if (m->gm_mech.gm_set_cred_option == NULL)
continue;
continue;
}
one_ok = 1;
- SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
+ HEIM_SLIST_INSERT_HEAD(&cred->gc_mc, mc, gmc_link);
}
*cred_handle = (gss_cred_id_t)cred;
if (!one_ok) {
} else {
gssapi_mech_interface m;
- SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
+ HEIM_SLIST_FOREACH(mc, &cred->gc_mc, gmc_link) {
m = mc->gmc_mech;
if (m == NULL)
#include <gssapi_mech.h>
struct _gss_mech_switch {
- SLIST_ENTRY(_gss_mech_switch) gm_link;
+ HEIM_SLIST_ENTRY(_gss_mech_switch) gm_link;
gss_OID_desc gm_mech_oid;
gss_OID_set gm_name_types;
void *gm_so;
gssapi_mech_interface_desc gm_mech;
};
-SLIST_HEAD(_gss_mech_switch_list, _gss_mech_switch);
+HEIM_SLIST_HEAD(_gss_mech_switch_list, _gss_mech_switch);
extern struct _gss_mech_switch_list _gss_mechs;
extern gss_OID_set _gss_mech_oids;
#ifndef _MECHQUEUE_H_
#define _MECHQUEUE_H_
-#ifndef SLIST_HEAD
-
/*
* Singly-linked List definitions.
*/
-#define SLIST_HEAD(name, type) \
+#define HEIM_SLIST_HEAD(name, type) \
struct name { \
struct type *slh_first; /* first element */ \
}
-#define SLIST_HEAD_INITIALIZER(head) \
+#define HEIM_SLIST_HEAD_INITIALIZER(head) \
{ NULL }
-#define SLIST_ENTRY(type) \
+#define HEIM_SLIST_ENTRY(type) \
struct { \
struct type *sle_next; /* next element */ \
}
/*
* Singly-linked List functions.
*/
-#define SLIST_INIT(head) do { \
+#define HEIM_SLIST_INIT(head) do { \
(head)->slh_first = NULL; \
} while (/*CONSTCOND*/0)
-#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
+#define HEIM_SLIST_INSERT_AFTER(slistelm, elm, field) do { \
(elm)->field.sle_next = (slistelm)->field.sle_next; \
(slistelm)->field.sle_next = (elm); \
} while (/*CONSTCOND*/0)
-#define SLIST_INSERT_HEAD(head, elm, field) do { \
+#define HEIM_SLIST_INSERT_HEAD(head, elm, field) do { \
(elm)->field.sle_next = (head)->slh_first; \
(head)->slh_first = (elm); \
} while (/*CONSTCOND*/0)
-#define SLIST_REMOVE_HEAD(head, field) do { \
+#define HEIM_SLIST_REMOVE_HEAD(head, field) do { \
(head)->slh_first = (head)->slh_first->field.sle_next; \
} while (/*CONSTCOND*/0)
-#define SLIST_REMOVE(head, elm, type, field) do { \
+#define HEIM_SLIST_REMOVE(head, elm, type, field) do { \
if ((head)->slh_first == (elm)) { \
- SLIST_REMOVE_HEAD((head), field); \
+ HEIM_SLIST_REMOVE_HEAD((head), field); \
} \
else { \
struct type *curelm = (head)->slh_first; \
} \
} while (/*CONSTCOND*/0)
-#define SLIST_FOREACH(var, head, field) \
+#define HEIM_SLIST_FOREACH(var, head, field) \
for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
/*
* Singly-linked List access methods.
*/
-#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
-#define SLIST_FIRST(head) ((head)->slh_first)
-#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-
-#endif /* SLIST_HEAD */
+#define HEIM_SLIST_EMPTY(head) ((head)->slh_first == NULL)
+#define HEIM_SLIST_FIRST(head) ((head)->slh_first)
+#define HEIM_SLIST_NEXT(elm, field) ((elm)->field.sle_next)
#endif /* !_MECHQUEUE_H_ */
*/
struct _gss_mechanism_name {
- SLIST_ENTRY(_gss_mechanism_name) gmn_link;
+ HEIM_SLIST_ENTRY(_gss_mechanism_name) gmn_link;
gssapi_mech_interface gmn_mech; /* mechanism ops for MN */
gss_OID gmn_mech_oid; /* mechanism oid for MN */
gss_name_t gmn_name; /* underlying MN */
};
-SLIST_HEAD(_gss_mechanism_name_list, _gss_mechanism_name);
+HEIM_SLIST_HEAD(_gss_mechanism_name_list, _gss_mechanism_name);
struct _gss_name {
gss_OID_desc gn_type; /* type of name */
#ifndef __HDB_H__
#define __HDB_H__
+#include <krb5.h>
+
#include <hdb_err.h>
#include <heim_asn1.h>
NULL
};
-static hx509_private_key_ops *
-find_private_alg(const heim_oid *oid)
+hx509_private_key_ops *
+hx509_find_private_alg(const heim_oid *oid)
{
int i;
for (i = 0; private_algs[i]; i++) {
*private_key = NULL;
- ops = find_private_alg(&keyai->algorithm);
+ ops = hx509_find_private_alg(&keyai->algorithm);
if (ops == NULL) {
hx509_clear_error_string(context);
return HX509_SIG_ALG_NO_SUPPORTED;
*private_key = NULL;
- ops = find_private_alg(ctx->key_oid);
+ ops = hx509_find_private_alg(ctx->key_oid);
if (ops == NULL) {
hx509_clear_error_string(context);
return HX509_SIG_ALG_NO_SUPPORTED;
typedef struct hx509_lock_data *hx509_lock;
typedef struct hx509_name_data *hx509_name;
typedef struct hx509_private_key *hx509_private_key;
+typedef struct hx509_private_key_ops hx509_private_key_ops;
typedef struct hx509_validate_ctx_data *hx509_validate_ctx;
typedef struct hx509_verify_ctx_data *hx509_verify_ctx;
typedef struct hx509_revoke_ctx_data *hx509_revoke_ctx;
typedef void (*_hx509_cert_release_func)(struct hx509_cert_data *, void *);
-typedef struct hx509_private_key_ops hx509_private_key_ops;
#include "sel.h"
global:
_hx509_cert_assign_key;
_hx509_cert_private_key;
+ _hx509_cert_public_encrypt;
_hx509_certs_keys_free;
_hx509_certs_keys_get;
_hx509_expr_eval;
_hx509_generate_private_key_is_ca;
_hx509_map_file_os;
_hx509_name_from_Name;
+ _hx509_parse_private_key;
+ _hx509_private_key_assign_rsa;
_hx509_private_key2SPKI;
_hx509_private_key_free;
+ _hx509_private_key_init;
+ _hx509_private_key_private_decrypt;
_hx509_private_key_ref;
_hx509_request_add_dns_name;
_hx509_request_add_email;
hx509_err;
hx509_free_error_string;
hx509_free_octet_string_list;
+ hx509_find_private_alg;
hx509_general_name_unparse;
hx509_get_error_string;
hx509_get_one_cert;
end = begin;
while (*end == '"') {
- char * t;
- while ((t = strchr(end + 1, '"')) != NULL && *(t - 1) == '\\') {
- --t;
- memmove(t, t + 1, strlen(t));
- end = t;
- }
+ char * t = strchr(end + 1, '"');
if (t)
end = ++t;
&_krb5_enctype_old_des3_cbc_sha1,
#endif
#ifdef HEIM_WEAK_CRYPTO
- &_krb5_enctype_des_cbc_crc,
- &_krb5_enctype_des_cbc_md4,
&_krb5_enctype_des_cbc_md5,
+ &_krb5_enctype_des_cbc_md4,
+ &_krb5_enctype_des_cbc_crc,
&_krb5_enctype_des_cbc_none,
&_krb5_enctype_des_cfb64_none,
&_krb5_enctype_des_pcbc_none,
return 0;
}
+static const char *
+keytab_name(const char * name, const char ** ptype, size_t * ptype_len)
+{
+ const char * residual;
+
+ residual = strchr(name, ':');
+
+ if (residual == NULL
+
+#ifdef _WIN32
+
+ /* Avoid treating <drive>:<path> as a keytab type
+ * specification */
+
+ || name + 1 == residual
+#endif
+ ) {
+
+ *ptype = "FILE";
+ *ptype_len = strlen(*ptype);
+ residual = name;
+ } else {
+ *ptype = name;
+ *ptype_len = residual - name;
+ residual++;
+ }
+
+ return residual;
+}
+
/**
* Resolve the keytab name (of the form `type:residual') in `name'
* into a keytab in `id'.
size_t type_len;
krb5_error_code ret;
- residual = strchr(name, ':');
- if(residual == NULL) {
- type = "FILE";
- type_len = strlen(type);
- residual = name;
- } else {
- type = name;
- type_len = residual - name;
- residual++;
- }
+ residual = keytab_name(name, &type, &type_len);
for(i = 0; i < context->num_kt_types; i++) {
if(strncasecmp(type, context->kt_types[i].prefix, type_len) == 0)
char buf[256];
while (strsep_copy(&name, ",", buf, sizeof(buf)) != -1) {
- a = malloc(sizeof(*a));
+ a = calloc(1, sizeof(*a));
if (a == NULL) {
ret = ENOMEM;
goto fail;
if (file == NULL)
file = MODULI_FILE;
+#ifdef KRB5_USE_PATH_TOKENS
+ {
+ char * exp_file;
+
+ if (_krb5_expand_path_tokens(context, file, &exp_file) == 0) {
+ f = fopen(exp_file, "r");
+ krb5_xfree(exp_file);
+ } else {
+ f = NULL;
+ }
+ }
+#else
f = fopen(file, "r");
+#endif
+
if (f == NULL) {
*moduli = m;
return 0;
#define MAXPATHLEN (1024+4)
#endif
-#else/* !_WIN32 */
-
-/* Minimize conflict with WinNT.h */
-#ifdef SLIST_ENTRY
-#undef SLIST_ENTRY
-#endif
-
-#endif /* _WIN32 */
+#endif /* !_WIN32 */
#ifndef PATH_MAX
#define PATH_MAX MAX_PATH
#endif
#ifndef HAVE_SSIZE_T
+#ifndef SSIZE_T_DEFINED
+#ifdef ssize_t
+#undef ssize_t
+#endif
#ifdef _WIN64
typedef __int64 ssize_t;
#else
typedef int ssize_t;
#endif
-#endif
+#define SSIZE_T_DEFINED
+#endif /* SSIZE_T_DEFINED */
+#endif /* HAVE_SSIZE_T */
#include <roken-common.h>
git.samba.org / samba.git / commitdiff