Authen-Krb5-Admin

 view release on metacpan or  search on metacpan

Admin.xs  view on Meta::CPAN

kadm5_delete_policy(handle, name)
    Authen::Krb5::Admin  handle
    char                *name
  CODE:
    err = kadm5_delete_policy(handle, name);
    if (err)
        XSRETURN_UNDEF;
    XSRETURN_YES;

void
kadm5_delete_principal(handle, princ)
    Authen::Krb5::Admin     handle
    Authen::Krb5::Principal princ
  CODE:
    err = kadm5_delete_principal(handle, princ);
    if (err)
        XSRETURN_UNDEF;
    XSRETURN_YES;

void
kadm5_error(e = 0)
    kadm5_ret_t e;
  CODE:
    if (e)
        ST(0) = sv_2mortal(newSVpv((char *)error_message(e), 0));
    else {
        ST(0) = sv_2mortal(newSVpv((char *)error_message(err), 0));
        SvUPGRADE(ST(0), SVt_PVIV);
        SvIVX(ST(0)) = err;
        SvIOK_on(ST(0));
    }

int
kadm5_error_code()
  CODE:
    RETVAL = err;
  OUTPUT:
    RETVAL

Authen::Krb5::Admin::Policy
kadm5_get_policy(handle, name = "default")
    Authen::Krb5::Admin  handle
    char                *name
  CODE:
    New(0, RETVAL, 1, struct kadm5_policy_mit);
    *RETVAL = kadm5_policy_mit_init;
    err = kadm5_get_policy(handle, name, &RETVAL->policy);
    if (err)
        XSRETURN_UNDEF;
  OUTPUT:
    RETVAL

void
kadm5_get_policies(handle, exp = NULL)
    Authen::Krb5::Admin  handle
    char                *exp
  PREINIT:
    char **pols;
    int    count;
    int    i;
  PPCODE:
    err = kadm5_get_policies(handle, exp, &pols, &count);
    if (err)
        XSRETURN_EMPTY;
    EXTEND(sp, count);
    for (i = 0; i < count; i++)
        PUSHs(sv_2mortal(newSVpv(pols[i], 0)));
    kadm5_free_name_list(handle, pols, count);
    XSRETURN(count);

Authen::Krb5::Admin::Principal
kadm5_get_principal(handle, krb5_princ, mask = KADM5_PRINCIPAL_NORMAL_MASK)
    Authen::Krb5::Admin     handle
    Authen::Krb5::Principal krb5_princ
    long                    mask
  PREINIT:
    char *tmp_policy;
    int   i;
    STRLEN len;
  CODE:
    New(0, RETVAL, 1, struct kadm5_principal_mit);  
    *RETVAL = kadm5_principal_mit_init;
    err = kadm5_get_principal(handle, krb5_princ, &RETVAL->kadm5_princ, mask);
    if (err)
        XSRETURN_UNDEF;
    if (RETVAL->kadm5_princ.n_key_data) {
        New(0, RETVAL->key_data, RETVAL->kadm5_princ.n_key_data, SV *);
        for (i = 0; i < RETVAL->kadm5_princ.n_key_data; i++) {
            krb5_key_data *p;
            New(0, p, 1, krb5_key_data);
            Copy(&RETVAL->kadm5_princ.key_data[i], p, 1, krb5_key_data);
            RETVAL->key_data[i] = newSViv(PTR2IV(p));
        }
    }
    RETVAL->krb5_princ = newSViv(PTR2IV(RETVAL->kadm5_princ.principal));
    RETVAL->krb5_princ_mod =
    newSViv(PTR2IV(RETVAL->kadm5_princ.mod_name));

    /*
     * When kadm5_get_principal() builds a kadm5_principal_ent_rec, it
     * malloc()s space for a policy name if the principal is
     * associated with one.  But when we build a
     * kadm5_principal_ent_rec (e.g., with Policy->name()), we use
     * New(), not malloc().  In DESTROY(), we don't want to Safefree()
     * memory not allocated with New(), so here we copy the policy
     * name to memory allocated with New() and free() what we were
     * handed by kadm5_get_principal().
     */

    if (RETVAL->kadm5_princ.policy) {
        len = strlen(RETVAL->kadm5_princ.policy);
        New(0, tmp_policy, len + 1, char);
        Copy(RETVAL->kadm5_princ.policy, tmp_policy, len + 1, char);
        free(RETVAL->kadm5_princ.policy);
        RETVAL->kadm5_princ.policy = tmp_policy;
    }
  OUTPUT:
    RETVAL

void
kadm5_get_principals(handle, exp = NULL)
    Authen::Krb5::Admin  handle
    char                *exp
  PREINIT:
    char **princs;
    int    count;
    int    i;
  PPCODE:
    err = kadm5_get_principals(handle, exp, &princs, &count);
    if (err)
        XSRETURN_EMPTY;
    EXTEND(sp, count);
    for (i = 0; i < count; i++)
        PUSHs(sv_2mortal(newSVpv(princs[i], 0)));
    kadm5_free_name_list(handle, princs, count);
    XSRETURN(count);

void
kadm5_get_privs(handle)
    Authen::Krb5::Admin handle
  PREINIT:
    long privs;
  CODE:
    err = kadm5_get_privs(handle, &privs);
    ST(0) = err ? &PL_sv_undef : sv_2mortal(newSViv(privs));

Authen::Krb5::Admin
kadm5_init_with_creds(CLASS, client, cc, service = KADM5_ADMIN_SERVICE, config = NULL, struct_version = KADM5_STRUCT_VERSION, api_version = KADM5_API_VERSION_2)
    char                        *CLASS
    char                        *client
    Authen::Krb5::Ccache         cc
    char                        *service
    Authen::Krb5::Admin::Config  config
    krb5_ui_4                    struct_version
    krb5_ui_4                    api_version
  CODE:
#ifdef KRB5_PLUGIN_NO_HANDLE    /* hack to test for 1.5 */
#ifdef KADM5_API_VERSION_3
    if (!context) {
        err = krb5_init_context(&context);
        if (err) die("Unable to initialize context");
    }
    err = kadm5_init_with_creds(context, client, cc, service, config,
      struct_version, api_version, NULL, &RETVAL);
#else
    err = kadm5_init_with_creds(client, cc, service, config, struct_version,
      api_version, NULL, &RETVAL);
#endif
#else
    err = kadm5_init_with_creds(client, cc, service, config, struct_version,
      api_version, &RETVAL);
#endif
    if (err)
        XSRETURN_UNDEF;
  OUTPUT:
    RETVAL

Authen::Krb5::Admin
kadm5_init_with_password(CLASS, client, pw = NULL, service = KADM5_ADMIN_SERVICE, config = NULL, struct_version = KADM5_STRUCT_VERSION, api_version = KADM5_API_VERSION_2)
    char                        *CLASS
    char                        *client
    char                        *pw
    char                        *service
    Authen::Krb5::Admin::Config  config
    krb5_ui_4                    struct_version
    krb5_ui_4                    api_version
  CODE:
#ifdef KRB5_PLUGIN_NO_HANDLE    /* hack to test for 1.5 */

Admin.xs  view on Meta::CPAN

Authen::Krb5::Admin
kadm5_init_with_skey(CLASS, client, keytab = NULL, service = KADM5_ADMIN_SERVICE, config = NULL, struct_version = KADM5_STRUCT_VERSION, api_version = KADM5_API_VERSION_2)
    char                        *CLASS
    char                        *client
    char                        *keytab
    char                        *service
    Authen::Krb5::Admin::Config  config
    krb5_ui_4                    struct_version
    krb5_ui_4                    api_version
  CODE:
#ifdef KRB5_PLUGIN_NO_HANDLE    /* hack to test for 1.5 */
#ifdef KADM5_API_VERSION_3
    if (!context) {
        err = krb5_init_context(&context);
        if (err) die("Unable to initialize context");
    }
    err = kadm5_init_with_skey(context, client, keytab, service,
      config, struct_version, api_version, NULL, &RETVAL);
#else
    err = kadm5_init_with_skey(client, keytab, service, config, struct_version,
      api_version, NULL, &RETVAL);
#endif
#else
    err = kadm5_init_with_skey(client, keytab, service, config, struct_version,
      api_version, &RETVAL);
#endif
    if (err)
        XSRETURN_UNDEF;
  OUTPUT:
    RETVAL

void
kadm5_modify_policy(handle, policy)
    Authen::Krb5::Admin         handle
    Authen::Krb5::Admin::Policy policy
  CODE:
    err = kadm5_modify_policy(handle, &policy->policy,
      policy->mask & ~KADM5_POLICY);
    if (err)
        XSRETURN_UNDEF;
    XSRETURN_YES;

void
kadm5_modify_principal(handle, princ)
    Authen::Krb5::Admin            handle
    Authen::Krb5::Admin::Principal princ
  CODE:
    err = kadm5_modify_principal(handle, &princ->kadm5_princ,
        princ->mask & ~KADM5_PRINCIPAL);
    if (err)
        XSRETURN_UNDEF;
    XSRETURN_YES;

void
kadm5_randkey_principal(handle, princ)
    Authen::Krb5::Admin     handle
    Authen::Krb5::Principal princ
  PREINIT:
    krb5_keyblock *keys;
    int            count, i;
  PPCODE:
    err = kadm5_randkey_principal(handle, princ, &keys, &count);
    if (err)
        XSRETURN_EMPTY;
    EXTEND(sp, count);
    for (i = 0; i < count; i++) {
        ST(i) = sv_newmortal();
        sv_setref_pv(ST(i), "Authen::Krb5::Keyblock", &keys[i]);
    }
    XSRETURN(count);

void
kadm5_rename_principal(handle, source, target)
    Authen::Krb5::Admin     handle
    Authen::Krb5::Principal source
    Authen::Krb5::Principal target
  CODE:
    err = kadm5_rename_principal(handle, source, target);
    if (err)
        XSRETURN_UNDEF;
    XSRETURN_YES;

void
DESTROY(handle)
    Authen::Krb5::Admin handle
  CODE:
    err = kadm5_destroy(handle);
    if (err)    
        XSRETURN_UNDEF;
    XSRETURN_YES;

 # 
 # kadm5_config_params class
 # 

MODULE = Authen::Krb5::Admin    PACKAGE = Authen::Krb5::Admin::Config

Authen::Krb5::Admin::Config
new(CLASS)
    char *CLASS
  CODE:
    New(0, RETVAL, 1, kadm5_config_params);
    *RETVAL = kadm5_config_params_init;
  OUTPUT:
    RETVAL

char *
admin_server(config, ...)
    Authen::Krb5::Admin::Config config
  PROTOTYPE: $;$
  PREINIT:
    STRLEN len;
  CODE:
    if (items > 1) {
        char *admin_server;
        admin_server = SvPV(ST(1), len);
        if (config->admin_server) {
            Safefree(config->admin_server);
            config->admin_server = NULL;
        }
        New(0, config->admin_server, len + 1, char);

Admin.xs  view on Meta::CPAN

 # kadm5_principal_ent_rec class--uses kadm5_principal_mit meta-struct
 # 

MODULE = Authen::Krb5::Admin    PACKAGE = Authen::Krb5::Admin::Principal

Authen::Krb5::Admin::Principal
new(CLASS)
    char *CLASS
  CODE:
    New(0, RETVAL, 1, struct kadm5_principal_mit);
    *RETVAL = kadm5_principal_mit_init;
    if (!RETVAL)
        XSRETURN_UNDEF;
  OUTPUT:
    RETVAL

krb5_flags
attributes(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        princ->kadm5_princ.attributes = SvIV(ST(1));
        princ->mask |= KADM5_ATTRIBUTES;
    }
    RETVAL = princ->kadm5_princ.attributes;
  OUTPUT:
    RETVAL

long
aux_attributes(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1)
        princ->kadm5_princ.aux_attributes = SvIV(ST(1));
    RETVAL = princ->kadm5_princ.aux_attributes;
  OUTPUT:
    RETVAL

krb5_kvno
fail_auth_count(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        princ->kadm5_princ.fail_auth_count = SvIV(ST(1));
        princ->mask |= KADM5_FAIL_AUTH_COUNT;
    }
    RETVAL = princ->kadm5_princ.fail_auth_count;
  OUTPUT:
    RETVAL

void
key_data(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  PREINIT:
    SV  **p;
    int   n;
  PPCODE:
    n = princ->kadm5_princ.n_key_data;
    if (items > 1) {
        for (p = princ->key_data; n--; p++)
            SvREFCNT_dec(*p);
        Renew(princ->key_data, items - 1, SV *);
        Renew(princ->kadm5_princ.key_data, items - 1, krb5_key_data);
        for (n = 0; n < items - 1; n++) {
            krb5_key_data *p;
            New(0, p, 1, krb5_key_data);
            Copy(INT2PTR(void *, SvIV(SvRV(ST(n + 1)))), p, 1, krb5_key_data);
            princ->key_data[n] = newSViv(PTR2IV(p));
            Copy(p, &princ->kadm5_princ.key_data[n], 1, krb5_key_data);
        }
        princ->kadm5_princ.n_key_data = items - 1;
        princ->mask |= KADM5_KEY_DATA;
    }
    n = princ->kadm5_princ.n_key_data;
    if (n > 0) {
        EXTEND(sp, n);
        for (p = princ->key_data; n--; p++)
            PUSHs(sv_2mortal(sv_bless(newRV_inc(*p),
              gv_stashpv("Authen::Krb5::Admin::Key", 0))));
    }

krb5_kvno
kvno(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        princ->kadm5_princ.kvno = SvUV(ST(1));
        princ->mask |= KADM5_KVNO;
    }
    RETVAL = princ->kadm5_princ.kvno;
  OUTPUT:
    RETVAL

krb5_timestamp
last_failed(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1)
        princ->kadm5_princ.last_failed = SvIV(ST(1));
    RETVAL = princ->kadm5_princ.last_failed;
  OUTPUT:
    RETVAL

krb5_timestamp
last_pwd_change(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1)
        princ->kadm5_princ.last_pwd_change = SvIV(ST(1));
    RETVAL = princ->kadm5_princ.last_pwd_change;
  OUTPUT:
    RETVAL

krb5_timestamp

Admin.xs  view on Meta::CPAN

        Safefree(princ->kadm5_princ.policy);
        princ->kadm5_princ.policy = NULL;
    }
    princ->mask &= ~KADM5_POLICY;
    princ->mask |= KADM5_POLICY_CLR;

krb5_timestamp
princ_expire_time(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        princ->kadm5_princ.princ_expire_time = SvIV(ST(1));
        princ->mask |= KADM5_PRINC_EXPIRE_TIME;
    }
    RETVAL = princ->kadm5_princ.princ_expire_time;
  OUTPUT:
    RETVAL

void
principal(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        if (princ->krb5_princ && SvIOK(princ->krb5_princ))
            SvREFCNT_dec(princ->krb5_princ);
        princ->krb5_princ = SvRV(ST(1));
        princ->kadm5_princ.principal =
          INT2PTR(krb5_principal, SvIV(princ->krb5_princ));
        SvREFCNT_inc(princ->krb5_princ);
        princ->mask |= KADM5_PRINCIPAL;
    }
    ST(0) = sv_2mortal(sv_bless(newRV_inc(princ->krb5_princ),
      gv_stashpv("Authen::Krb5::Principal", 0)));

krb5_timestamp
pw_expiration(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;$
  CODE:
    if (items > 1) {
        princ->kadm5_princ.pw_expiration = SvIV(ST(1));
        princ->mask |= KADM5_PW_EXPIRATION;
    }
    RETVAL = princ->kadm5_princ.pw_expiration;
  OUTPUT:
    RETVAL

#ifdef HAVE_KDB_H

void
db_args(princ, ...)
    Authen::Krb5::Admin::Principal princ
  PROTOTYPE: $;@
  PREINIT:
    krb5_tl_data *tl, *last_tl;
    krb5_octet **db_args;
    int i;

  PPCODE:
    /* arglist will be items - 1, but the last item should be a NULL. */
    Newxz(db_args, items, krb5_octet *);

    /* pull db args off the stack */
    /* grab the arg stack */
    for (i = 1; i < items; i++) {
        krb5_octet *this_arg;
        STRLEN length = sv_len(ST(i)) + 1;
        /* Perl_croak(aTHX_ "%d", length);*/
        Newxz(this_arg, length, krb5_octet);
        Copy((krb5_octet *)SvPV(ST(i), length), this_arg, length, krb5_octet);
        /* db_args[i - 1] = (krb5_octet *)SvPV_nolen(ST(i)); */
        db_args[i - 1] = this_arg;
    }

    last_tl = NULL;
    tl      = princ->kadm5_princ.tl_data;
    while (tl != NULL) {
        krb5_tl_data *next_tl = tl->tl_data_next;

        /* bail out early for anything but db_args */
        if (tl->tl_data_type != KRB5_TL_DB_ARGS) {
            last_tl = tl;
            tl      = next_tl;
            continue;
        }

        /* otherwise: */

        /* pinched from kdb5.c */
        if (((char *) tl->tl_data_contents)[tl->tl_data_length - 1] != '\0') {
            /* croak */
            Perl_croak(aTHX_ "Unsafe string in principal tail data");
        }
        else {
            SV * tl_out;
            
            tl_out = newSVpv((const char *) tl->tl_data_contents, 0);
            XPUSHs(tl_out);

            /* extend and push the stack with a new mortal SvPV */
            /* mXPUSHp((char *) tl->tl_data_contents, tl->tl_data_length - 1); */
            /* only two hard things in computer science: cache
               expiration, naming things, and off-by-one errors. */

            /* PS that copies the string, right? because i'm about to
               nuke it. */
    
            /* we're only doing surgery if there is something to
               replace these with */
            if (items > 1) {
                /* stitch next record to last record if it exists */
                if (last_tl != NULL) last_tl->tl_data_next = next_tl;
                /* stitch the next one onto if this is the first */
                else if (tl == princ->kadm5_princ.tl_data)
                    princ->kadm5_princ.tl_data = next_tl;

                /* poof */
                free(tl->tl_data_contents);
                free(tl);