← Back to branch summary

~hartmans/ubuntu/trusty/krb5/gss-infinite-loop

« back to all changes in this revision

Viewing changes to src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs
  • Date: 2013-11-10 02:20:12 UTC
  • mfrom: (53.1.3 trusty-proposed)
  • Revision ID: package-import@ubuntu.com-20131110022012-b8ojkqhcxos55kln
Tags: 1.11.3+dfsg-3ubuntu2
Add alternate dependency on libverto-libevent1 as that's the package
ABI name in ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/kdb/ldap/libkdb_ldap/ldap_realm.c
389
389
    LDAP                  *ld=NULL;
390
390
    krb5_error_code       st=0;
391
391
    char                  **strval=NULL, *strvalprc[5]={NULL};
392
 
#ifdef HAVE_EDIRECTORY
393
 
    char                  **values=NULL;
394
 
    char                  **oldkdcservers=NULL, **oldadminservers=NULL, **oldpasswdservers=NULL;
395
 
    LDAPMessage           *result=NULL, *ent=NULL;
396
 
    int                   count=0;
397
 
    char errbuf[1024];
398
 
#endif
399
392
    LDAPMod               **mods = NULL;
400
 
#ifdef HAVE_EDIRECTORY
401
 
    int                   i=0;
402
 
#endif
403
393
    int                   oldmask=0, objectmask=0,k=0;
404
394
    kdb5_dal_handle       *dal_handle=NULL;
405
395
    krb5_ldap_context     *ldap_context=NULL;
421
411
        rparams->tl_data->tl_data_contents == NULL ||
422
412
        ((mask & LDAP_REALM_SUBTREE) && rparams->subtree == NULL) ||
423
413
        ((mask & LDAP_REALM_CONTREF) && rparams->containerref == NULL) ||
424
 
#ifdef HAVE_EDIRECTORY
425
 
        ((mask & LDAP_REALM_KDCSERVERS) && rparams->kdcservers == NULL) ||
426
 
        ((mask & LDAP_REALM_ADMINSERVERS) && rparams->adminservers == NULL) ||
427
 
        ((mask & LDAP_REALM_PASSWDSERVERS) && rparams->passwdservers == NULL) ||
428
 
#endif
429
414
        0) {
430
415
        st = EINVAL;
431
416
        goto cleanup;
518
503
    }
519
504
 
520
505
 
521
 
#ifdef HAVE_EDIRECTORY
522
 
 
523
 
    /* KDCSERVERS ATTRIBUTE */
524
 
    if (mask & LDAP_REALM_KDCSERVERS) {
525
 
        /* validate the server list */
526
 
        for (i=0; rparams->kdcservers[i] != NULL; ++i) {
527
 
            st = checkattributevalue(ld, rparams->kdcservers[i], "objectClass", kdcclass,
528
 
                                     &objectmask);
529
 
            CHECK_CLASS_VALIDITY(st, objectmask,
530
 
                                 _("kdc service object value: "));
531
 
        }
532
 
 
533
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbkdcservers", LDAP_MOD_REPLACE,
534
 
                                          rparams->kdcservers)) != 0)
535
 
            goto cleanup;
536
 
    }
537
 
 
538
 
    /* ADMINSERVERS ATTRIBUTE */
539
 
    if (mask & LDAP_REALM_ADMINSERVERS) {
540
 
        /* validate the server list */
541
 
        for (i=0; rparams->adminservers[i] != NULL; ++i) {
542
 
            st = checkattributevalue(ld, rparams->adminservers[i], "objectClass", adminclass,
543
 
                                     &objectmask);
544
 
            CHECK_CLASS_VALIDITY(st, objectmask,
545
 
                                 _("admin service object value: "));
546
 
        }
547
 
 
548
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbadmservers", LDAP_MOD_REPLACE,
549
 
                                          rparams->adminservers)) != 0)
550
 
            goto cleanup;
551
 
    }
552
 
 
553
 
    /* PASSWDSERVERS ATTRIBUTE */
554
 
    if (mask & LDAP_REALM_PASSWDSERVERS) {
555
 
        /* validate the server list */
556
 
        for (i=0; rparams->passwdservers[i] != NULL; ++i) {
557
 
            st = checkattributevalue(ld, rparams->passwdservers[i], "objectClass", pwdclass,
558
 
                                     &objectmask);
559
 
            CHECK_CLASS_VALIDITY(st, objectmask,
560
 
                                 _("password service object value: "));
561
 
        }
562
 
 
563
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbpwdservers", LDAP_MOD_REPLACE,
564
 
                                          rparams->passwdservers)) != 0)
565
 
            goto cleanup;
566
 
    }
567
 
 
568
 
    /*
569
 
     * Read the old values of the krbkdcservers, krbadmservers and
570
 
     * krbpwdservers.  This information is later used to decided the
571
 
     * deletions/additions to the list.
572
 
     */
573
 
    if (mask & LDAP_REALM_KDCSERVERS || mask & LDAP_REALM_ADMINSERVERS ||
574
 
        mask & LDAP_REALM_PASSWDSERVERS) {
575
 
        char *servers[] = {"krbKdcServers", "krbAdmServers", "krbPwdServers", NULL};
576
 
 
577
 
        if ((st= ldap_search_ext_s(ld,
578
 
                                   rparams->realmdn,
579
 
                                   LDAP_SCOPE_BASE,
580
 
                                   0,
581
 
                                   servers,
582
 
                                   0,
583
 
                                   NULL,
584
 
                                   NULL,
585
 
                                   NULL,
586
 
                                   0,
587
 
                                   &result)) != LDAP_SUCCESS) {
588
 
            st = set_ldap_error (context, st, OP_SEARCH);
589
 
            goto cleanup;
590
 
        }
591
 
 
592
 
        ent = ldap_first_entry(ld, result);
593
 
        if (ent) {
594
 
            if ((values=ldap_get_values(ld, ent, "krbKdcServers")) != NULL) {
595
 
                count = ldap_count_values(values);
596
 
                if ((st=copy_arrays(values, &oldkdcservers, count)) != 0)
597
 
                    goto cleanup;
598
 
                ldap_value_free(values);
599
 
            }
600
 
 
601
 
            if ((values=ldap_get_values(ld, ent, "krbAdmServers")) != NULL) {
602
 
                count = ldap_count_values(values);
603
 
                if ((st=copy_arrays(values, &oldadminservers, count)) != 0)
604
 
                    goto cleanup;
605
 
                ldap_value_free(values);
606
 
            }
607
 
 
608
 
            if ((values=ldap_get_values(ld, ent, "krbPwdServers")) != NULL) {
609
 
                count = ldap_count_values(values);
610
 
                if ((st=copy_arrays(values, &oldpasswdservers, count)) != 0)
611
 
                    goto cleanup;
612
 
                ldap_value_free(values);
613
 
            }
614
 
        }
615
 
        ldap_msgfree(result);
616
 
    }
617
 
#endif
618
 
 
619
506
    /* Realm modify opearation */
620
507
    if (mods != NULL) {
621
508
        if ((st=ldap_modify_ext_s(ld, rparams->realmdn, mods, NULL, NULL)) != LDAP_SUCCESS) {
624
511
        }
625
512
    }
626
513
 
627
 
#ifdef HAVE_EDIRECTORY
628
 
    /* krbRealmReferences attribute is updated here, depending on the additions/deletions
629
 
     * to the 4 servers' list.
630
 
     */
631
 
    if (mask & LDAP_REALM_KDCSERVERS) {
632
 
        char **newkdcservers=NULL;
633
 
 
634
 
        count = ldap_count_values(rparams->kdcservers);
635
 
        if ((st=copy_arrays(rparams->kdcservers, &newkdcservers, count)) != 0)
636
 
            goto cleanup;
637
 
 
638
 
        /* find the deletions and additions to the server list */
639
 
        if (oldkdcservers && newkdcservers)
640
 
            disjoint_members(oldkdcservers, newkdcservers);
641
 
 
642
 
        /* delete the krbRealmReferences attribute from the servers that are dis-associated. */
643
 
        if (oldkdcservers)
644
 
            for (i=0; oldkdcservers[i]; ++i)
645
 
                if ((st=deleteAttribute(ld, oldkdcservers[i], "krbRealmReferences",
646
 
                                        rparams->realmdn)) != 0) {
647
 
                    snprintf(errbuf, sizeof(errbuf),
648
 
                             _("Error removing 'krbRealmReferences' from "
649
 
                               "%s: "), oldkdcservers[i]);
650
 
                    prepend_err_str(context, errbuf, st, st);
651
 
                    goto cleanup;
652
 
                }
653
 
 
654
 
        /* add the krbRealmReferences attribute from the servers that are associated. */
655
 
        if (newkdcservers)
656
 
            for (i=0; newkdcservers[i]; ++i)
657
 
                if ((st=updateAttribute(ld, newkdcservers[i], "krbRealmReferences",
658
 
                                        rparams->realmdn)) != 0) {
659
 
                    snprintf(errbuf, sizeof(errbuf),
660
 
                             _("Error adding 'krbRealmReferences' to %s: "),
661
 
                             newkdcservers[i]);
662
 
                    prepend_err_str(context, errbuf, st, st);
663
 
                    goto cleanup;
664
 
                }
665
 
 
666
 
        if (newkdcservers)
667
 
            ldap_value_free(newkdcservers);
668
 
    }
669
 
 
670
 
    if (mask & LDAP_REALM_ADMINSERVERS) {
671
 
        char **newadminservers=NULL;
672
 
 
673
 
        count = ldap_count_values(rparams->adminservers);
674
 
        if ((st=copy_arrays(rparams->adminservers, &newadminservers, count)) != 0)
675
 
            goto cleanup;
676
 
 
677
 
        /* find the deletions and additions to the server list */
678
 
        if (oldadminservers && newadminservers)
679
 
            disjoint_members(oldadminservers, newadminservers);
680
 
 
681
 
        /* delete the krbRealmReferences attribute from the servers that are dis-associated. */
682
 
        if (oldadminservers)
683
 
            for (i=0; oldadminservers[i]; ++i)
684
 
                if ((st=deleteAttribute(ld, oldadminservers[i], "krbRealmReferences",
685
 
                                        rparams->realmdn)) != 0) {
686
 
                    snprintf(errbuf, sizeof(errbuf),
687
 
                             _("Error removing 'krbRealmReferences' from "
688
 
                               "%s: "), oldadminservers[i]);
689
 
                    prepend_err_str(context, errbuf, st, st);
690
 
                    goto cleanup;
691
 
                }
692
 
 
693
 
        /* add the krbRealmReferences attribute from the servers that are associated. */
694
 
        if (newadminservers)
695
 
            for (i=0; newadminservers[i]; ++i)
696
 
                if ((st=updateAttribute(ld, newadminservers[i], "krbRealmReferences",
697
 
                                        rparams->realmdn)) != 0) {
698
 
                    snprintf(errbuf, sizeof(errbuf),
699
 
                             _("Error adding 'krbRealmReferences' to %s: "),
700
 
                             newadminservers[i]);
701
 
                    prepend_err_str(context, errbuf, st, st);
702
 
                    goto cleanup;
703
 
                }
704
 
        if (newadminservers)
705
 
            ldap_value_free(newadminservers);
706
 
    }
707
 
 
708
 
    if (mask & LDAP_REALM_PASSWDSERVERS) {
709
 
        char **newpasswdservers=NULL;
710
 
 
711
 
        count = ldap_count_values(rparams->passwdservers);
712
 
        if ((st=copy_arrays(rparams->passwdservers, &newpasswdservers, count)) != 0)
713
 
            goto cleanup;
714
 
 
715
 
        /* find the deletions and additions to the server list */
716
 
        if (oldpasswdservers && newpasswdservers)
717
 
            disjoint_members(oldpasswdservers, newpasswdservers);
718
 
 
719
 
        /* delete the krbRealmReferences attribute from the servers that are dis-associated. */
720
 
        if (oldpasswdservers)
721
 
            for (i=0; oldpasswdservers[i]; ++i)
722
 
                if ((st=deleteAttribute(ld, oldpasswdservers[i], "krbRealmReferences",
723
 
                                        rparams->realmdn)) != 0) {
724
 
                    snprintf(errbuf, sizeof(errbuf),
725
 
                             _("Error removing 'krbRealmReferences' from "
726
 
                               "%s: "), oldpasswdservers[i]);
727
 
                    prepend_err_str(context, errbuf, st, st);
728
 
                    goto cleanup;
729
 
                }
730
 
 
731
 
        /* add the krbRealmReferences attribute from the servers that are associated. */
732
 
        if (newpasswdservers)
733
 
            for (i=0; newpasswdservers[i]; ++i)
734
 
                if ((st=updateAttribute(ld, newpasswdservers[i], "krbRealmReferences",
735
 
                                        rparams->realmdn)) != 0) {
736
 
                    snprintf(errbuf, sizeof(errbuf),
737
 
                             _("Error adding 'krbRealmReferences' to %s: "),
738
 
                             newpasswdservers[i]);
739
 
                    prepend_err_str(context, errbuf, st, st);
740
 
                    goto cleanup;
741
 
                }
742
 
        if (newpasswdservers)
743
 
            ldap_value_free(newpasswdservers);
744
 
    }
745
 
#endif
746
 
 
747
514
cleanup:
748
515
 
749
 
#ifdef HAVE_EDIRECTORY
750
 
    if (oldkdcservers) {
751
 
        for (i=0; oldkdcservers[i]; ++i)
752
 
            free(oldkdcservers[i]);
753
 
        free(oldkdcservers);
754
 
    }
755
 
 
756
 
    if (oldadminservers) {
757
 
        for (i=0; oldadminservers[i]; ++i)
758
 
            free(oldadminservers[i]);
759
 
        free(oldadminservers);
760
 
    }
761
 
 
762
 
    if (oldpasswdservers) {
763
 
        for (i=0; oldpasswdservers[i]; ++i)
764
 
            free(oldpasswdservers[i]);
765
 
        free(oldpasswdservers);
766
 
    }
767
 
#endif
768
 
 
769
516
    ldap_mods_free(mods, 1);
770
517
    krb5_ldap_put_handle_to_pool(ldap_context, ldap_server_handle);
771
518
    return st;
790
537
    kdb5_dal_handle             *dal_handle=NULL;
791
538
    krb5_ldap_context           *ldap_context=NULL;
792
539
    krb5_ldap_server_handle     *ldap_server_handle=NULL;
793
 
#ifdef HAVE_EDIRECTORY
794
 
    int                         crmask=0;
795
 
#endif
796
540
 
797
541
    SETUP_CONTEXT ();
798
542
 
802
546
    if (krbcontparams != NULL && krbcontparams->DN != NULL) {
803
547
        kerberoscontdn = krbcontparams->DN;
804
548
    } else {
805
 
        /* If the user has not given, use the default cn=Kerberos,cn=Security */
806
 
#ifdef HAVE_EDIRECTORY
807
 
        kerberoscontdn = KERBEROS_CONTAINER;
808
 
#else
809
549
        st = EINVAL;
810
550
        krb5_set_error_message(context, st,
811
551
                               _("Kerberos Container information is missing"));
812
552
        goto cleanup;
813
 
#endif
814
553
    }
815
554
 
816
555
    strval[0] = "krbContainer";
854
593
        goto cleanup;
855
594
    }
856
595
 
857
 
#ifdef HAVE_EDIRECTORY
858
 
 
859
 
    /* free the mods array */
860
 
    ldap_mods_free(mods, 1);
861
 
    mods=NULL;
862
 
 
863
 
    /* check whether the security container is bound to krbcontainerrefaux object class */
864
 
    if ((st=checkattributevalue(ld, SECURITY_CONTAINER, "objectClass",
865
 
                                krbContainerRefclass, &crmask)) != 0) {
866
 
        prepend_err_str(context, _("Security Container read FAILED: "), st,
867
 
                        st);
868
 
        /* delete Kerberos Container, status ignored intentionally */
869
 
        ldap_delete_ext_s(ld, kerberoscontdn, NULL, NULL);
870
 
        goto cleanup;
871
 
    }
872
 
 
873
 
    if (crmask == 0) {
874
 
        /* Security Container is extended with krbcontainerrefaux object class */
875
 
        strval[0] = "krbContainerRefAux";
876
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "objectclass", LDAP_MOD_ADD, strval)) != 0)
877
 
            goto cleanup;
878
 
    }
879
 
 
880
 
    strval[0] = kerberoscontdn;
881
 
    strval[1] = NULL;
882
 
    if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbcontainerreference", LDAP_MOD_ADD, strval)) != 0)
883
 
        goto cleanup;
884
 
 
885
 
    /* update the security container with krbContainerReference attribute */
886
 
    if ((st=ldap_modify_ext_s(ld, SECURITY_CONTAINER, mods, NULL, NULL)) != LDAP_SUCCESS) {
887
 
        int ost = st;
888
 
        st = translate_ldap_error (st, OP_MOD);
889
 
        krb5_set_error_message(context, st,
890
 
                               _("Security Container update FAILED: %s"),
891
 
                               ldap_err2string(ost));
892
 
        /* delete Kerberos Container, status ignored intentionally */
893
 
        ldap_delete_ext_s(ld, kerberoscontdn, NULL, NULL);
894
 
        goto cleanup;
895
 
    }
896
 
#endif
897
 
 
898
596
cleanup:
899
597
 
900
598
    if (rdns)
929
627
    if (krbcontparams != NULL && krbcontparams->DN != NULL) {
930
628
        kerberoscontdn = krbcontparams->DN;
931
629
    } else {
932
 
        /* If the user has not given, use the default cn=Kerberos,cn=Security */
933
 
#ifdef HAVE_EDIRECTORY
934
 
        kerberoscontdn = KERBEROS_CONTAINER;
935
 
#else
936
630
        st = EINVAL;
937
631
        krb5_set_error_message(context, st,
938
632
                               _("Kerberos Container information is missing"));
939
633
        goto cleanup;
940
 
#endif
941
634
    }
942
635
 
943
636
    /* delete the kerberos container */
975
668
    kdb5_dal_handle             *dal_handle=NULL;
976
669
    krb5_ldap_context           *ldap_context=NULL;
977
670
    krb5_ldap_server_handle     *ldap_server_handle=NULL;
978
 
#ifdef HAVE_EDIRECTORY
979
 
    char errbuf[1024];
980
 
#endif
981
671
    char                        *realm_name;
982
672
 
983
673
    SETUP_CONTEXT ();
990
680
        ((mask & LDAP_REALM_SUBTREE) && rparams->subtree  == NULL) ||
991
681
        ((mask & LDAP_REALM_CONTREF) && rparams->containerref == NULL) ||
992
682
        ((mask & LDAP_REALM_POLICYREFERENCE) && rparams->policyreference == NULL) ||
993
 
#ifdef HAVE_EDIRECTORY
994
 
        ((mask & LDAP_REALM_KDCSERVERS) && rparams->kdcservers == NULL) ||
995
 
        ((mask & LDAP_REALM_ADMINSERVERS) && rparams->adminservers == NULL) ||
996
 
        ((mask & LDAP_REALM_PASSWDSERVERS) && rparams->passwdservers == NULL) ||
997
 
#endif
998
683
        0) {
999
684
        st = EINVAL;
1000
685
        return st;
1096
781
    }
1097
782
 
1098
783
 
1099
 
#ifdef HAVE_EDIRECTORY
1100
 
 
1101
 
    /* KDCSERVERS ATTRIBUTE */
1102
 
    if (mask & LDAP_REALM_KDCSERVERS) {
1103
 
        /* validate the server list */
1104
 
        for (i=0; rparams->kdcservers[i] != NULL; ++i) {
1105
 
            st = checkattributevalue(ld, rparams->kdcservers[i], "objectClass", kdcclass,
1106
 
                                     &objectmask);
1107
 
            CHECK_CLASS_VALIDITY(st, objectmask,
1108
 
                                 _("kdc service object value: "));
1109
 
 
1110
 
        }
1111
 
 
1112
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbkdcservers", LDAP_MOD_ADD,
1113
 
                                          rparams->kdcservers)) != 0)
1114
 
            goto cleanup;
1115
 
    }
1116
 
 
1117
 
    /* ADMINSERVERS ATTRIBUTE */
1118
 
    if (mask & LDAP_REALM_ADMINSERVERS) {
1119
 
        /* validate the server list */
1120
 
        for (i=0; rparams->adminservers[i] != NULL; ++i) {
1121
 
            st = checkattributevalue(ld, rparams->adminservers[i], "objectClass", adminclass,
1122
 
                                     &objectmask);
1123
 
            CHECK_CLASS_VALIDITY(st, objectmask,
1124
 
                                 _("admin service object value: "));
1125
 
 
1126
 
        }
1127
 
 
1128
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbadmservers", LDAP_MOD_ADD,
1129
 
                                          rparams->adminservers)) != 0)
1130
 
            goto cleanup;
1131
 
    }
1132
 
 
1133
 
    /* PASSWDSERVERS ATTRIBUTE */
1134
 
    if (mask & LDAP_REALM_PASSWDSERVERS) {
1135
 
        /* validate the server list */
1136
 
        for (i=0; rparams->passwdservers[i] != NULL; ++i) {
1137
 
            st = checkattributevalue(ld, rparams->passwdservers[i], "objectClass", pwdclass,
1138
 
                                     &objectmask);
1139
 
            CHECK_CLASS_VALIDITY(st, objectmask, "password service object value: ");
1140
 
 
1141
 
        }
1142
 
 
1143
 
        if ((st=krb5_add_str_mem_ldap_mod(&mods, "krbpwdservers", LDAP_MOD_ADD,
1144
 
                                          rparams->passwdservers)) != 0)
1145
 
            goto cleanup;
1146
 
    }
1147
 
#endif
1148
 
 
1149
784
    /* realm creation operation */
1150
785
    if ((st=ldap_add_ext_s(ld, dn, mods, NULL, NULL)) != LDAP_SUCCESS) {
1151
786
        st = set_ldap_error (context, st, OP_ADD);
1152
787
        goto cleanup;
1153
788
    }
1154
789
 
1155
 
#ifdef HAVE_EDIRECTORY
1156
 
    if (mask & LDAP_REALM_KDCSERVERS)
1157
 
        for (i=0; rparams->kdcservers[i]; ++i)
1158
 
            if ((st=updateAttribute(ld, rparams->kdcservers[i], "krbRealmReferences", dn)) != 0) {
1159
 
                snprintf(errbuf, sizeof(errbuf),
1160
 
                         _("Error adding 'krbRealmReferences' to %s: "),
1161
 
                         rparams->kdcservers[i]);
1162
 
                prepend_err_str (context, errbuf, st, st);
1163
 
                /* delete Realm, status ignored intentionally */
1164
 
                ldap_delete_ext_s(ld, dn, NULL, NULL);
1165
 
                goto cleanup;
1166
 
            }
1167
 
 
1168
 
    if (mask & LDAP_REALM_ADMINSERVERS)
1169
 
        for (i=0; rparams->adminservers[i]; ++i)
1170
 
            if ((st=updateAttribute(ld, rparams->adminservers[i], "krbRealmReferences", dn)) != 0) {
1171
 
                snprintf(errbuf, sizeof(errbuf),
1172
 
                         _("Error adding 'krbRealmReferences' to %s: "),
1173
 
                         rparams->adminservers[i]);
1174
 
                prepend_err_str (context, errbuf, st, st);
1175
 
                /* delete Realm, status ignored intentionally */
1176
 
                ldap_delete_ext_s(ld, dn, NULL, NULL);
1177
 
                goto cleanup;
1178
 
            }
1179
 
 
1180
 
    if (mask & LDAP_REALM_PASSWDSERVERS)
1181
 
        for (i=0; rparams->passwdservers[i]; ++i)
1182
 
            if ((st=updateAttribute(ld, rparams->passwdservers[i], "krbRealmReferences", dn)) != 0) {
1183
 
                snprintf(errbuf, sizeof(errbuf),
1184
 
                         _("Error adding 'krbRealmReferences' to %s: "),
1185
 
                         rparams->passwdservers[i]);
1186
 
                prepend_err_str (context, errbuf, st, st);
1187
 
                /* delete Realm, status ignored intentionally */
1188
 
                ldap_delete_ext_s(ld, dn, NULL, NULL);
1189
 
                goto cleanup;
1190
 
            }
1191
 
#endif
1192
 
 
1193
790
cleanup:
1194
791
 
1195
792
    if (dn)
1209
806
                            krb5_ldap_realm_params **rlparamp, int *mask)
1210
807
{
1211
808
    char                   **values=NULL, *krbcontDN=NULL /*, *curr=NULL */;
1212
 
#ifdef HAVE_EDIRECTORY
1213
 
    unsigned int           count=0;
1214
 
#endif
1215
809
    krb5_error_code        st=0, tempst=0;
1216
810
    LDAP                   *ld=NULL;
1217
811
    LDAPMessage            *result=NULL,*ent=NULL;
1349
943
            ldap_value_free(values);
1350
944
        }
1351
945
 
1352
 
#ifdef HAVE_EDIRECTORY
1353
 
 
1354
 
        if ((values=ldap_get_values(ld, ent, "krbKdcServers")) != NULL) {
1355
 
            count = ldap_count_values(values);
1356
 
            if ((st=copy_arrays(values, &(rlparams->kdcservers), (int) count)) != 0)
1357
 
                goto cleanup;
1358
 
            *mask |= LDAP_REALM_KDCSERVERS;
1359
 
            ldap_value_free(values);
1360
 
        }
1361
 
 
1362
 
        if ((values=ldap_get_values(ld, ent, "krbAdmServers")) != NULL) {
1363
 
            count = ldap_count_values(values);
1364
 
            if ((st=copy_arrays(values, &(rlparams->adminservers), (int) count)) != 0)
1365
 
                goto cleanup;
1366
 
            *mask |= LDAP_REALM_ADMINSERVERS;
1367
 
            ldap_value_free(values);
1368
 
        }
1369
 
 
1370
 
        if ((values=ldap_get_values(ld, ent, "krbPwdServers")) != NULL) {
1371
 
            count = ldap_count_values(values);
1372
 
            if ((st=copy_arrays(values, &(rlparams->passwdservers), (int) count)) != 0)
1373
 
                goto cleanup;
1374
 
            *mask |= LDAP_REALM_PASSWDSERVERS;
1375
 
            ldap_value_free(values);
1376
 
        }
1377
 
#endif
1378
946
    }
1379
947
    ldap_msgfree(result);
1380
948