← Back to branch summary

~ubuntu-branches/ubuntu/maverick/krb5/maverick

« back to all changes in this revision

Viewing changes to src/lib/kadm5/alt_prof.c

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hartman
  • Date: 2009-05-07 16:16:34 UTC
  • mfrom: (13.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20090507161634-xqyk0s9na0le4flj
Tags: 1.7dfsg~beta1-4
http://bugs.debian.org/527353
When  decrypting the TGS response fails with the subkey, try with the
session key to work around Heimdal bug, Closes: #527353 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/kadm5/alt_prof.c
1
1
/*
2
2
 * lib/kadm/alt_prof.c
3
3
 *
4
 
 * Copyright 1995,2001 by the Massachusetts Institute of Technology.
 
4
 * Copyright 1995,2001,2008,2009 by the Massachusetts Institute of Technology.
5
5
 * All Rights Reserved.
6
6
 *
7
7
 * Export of this software from the United States of America may
24
24
 * or implied warranty.
25
25
 *
26
26
 */
 
27
/*
 
28
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 
29
 * Use is subject to license terms.
 
30
 */
27
31
 
28
32
/*
29
33
 * alt_prof.c - Implement alternate profile file handling.
33
37
#include "adm_proto.h"
34
38
#include <stdio.h>
35
39
#include <ctype.h>
 
40
#include <kdb_log.h>
36
41
 
 
42
krb5_boolean krb5_match_config_pattern(const char *, const char*);
37
43
static krb5_key_salt_tuple *copy_key_salt_tuple(ksalt, len)
38
44
krb5_key_salt_tuple *ksalt;
39
45
krb5_int32 len;
41
47
    krb5_key_salt_tuple *knew;    
42
48
 
43
49
    if((knew = (krb5_key_salt_tuple *)
44
 
                malloc((len ) * sizeof(krb5_key_salt_tuple)))) {
 
50
                malloc((len ) * sizeof(krb5_key_salt_tuple)))) {
45
51
         memcpy(knew, ksalt, len * sizeof(krb5_key_salt_tuple));
46
 
         return knew;
 
52
         return knew;
47
53
    }
48
54
    return 0;
49
55
}
50
56
 
51
57
/*
52
 
 * krb5_aprof_init()    - Initialize alternate profile context.
 
58
 * krb5_aprof_init()        - Initialize alternate profile context.
53
59
 *
54
60
 * Parameters:
55
 
 *      fname           - default file name of the profile.
56
 
 *      envname         - environment variable name which can override fname.
57
 
 *      acontextp       - Pointer to opaque context for alternate profile.
 
61
 *        fname                - default file name of the profile.
 
62
 *        envname                - environment variable name which can override fname.
 
63
 *        acontextp        - Pointer to opaque context for alternate profile.
58
64
 *
59
65
 * Returns:
60
 
 *      error codes from profile_init()
 
66
 *        error codes from profile_init()
61
67
 */
62
68
krb5_error_code
63
69
krb5_aprof_init(fname, envname, acontextp)
64
 
    char                *fname;
65
 
    char                *envname;
66
 
    krb5_pointer        *acontextp;
 
70
    char                *fname;
 
71
    char                *envname;
 
72
    krb5_pointer        *acontextp;
67
73
{
68
 
    krb5_error_code     kret;
69
 
    profile_t           profile;
70
 
    const char *kdc_config;
71
 
    size_t krb5_config_len, kdc_config_len;
72
 
    char *profile_path;
73
 
    char **filenames;
74
 
    int i;
 
74
    krb5_error_code kret;
 
75
    profile_t       profile;
 
76
    const char      *kdc_config;
 
77
    char            *profile_path;
 
78
    char            **filenames;
 
79
    int             i;
 
80
    struct          k5buf buf;
75
81
 
76
82
    kret = krb5_get_default_config_files (&filenames);
77
83
    if (kret)
78
 
        return kret;
79
 
    krb5_config_len = 0;
80
 
    for (i = 0; filenames[i] != NULL; i++)
81
 
        krb5_config_len += strlen(filenames[i]) + 1;
82
 
    if (i > 0)
83
 
        krb5_config_len--;
84
 
    if (envname == NULL
85
 
        || (kdc_config = getenv(envname)) == NULL)
86
 
        kdc_config = fname;
87
 
    if (kdc_config == NULL)
88
 
        kdc_config_len = 0;
89
 
    else
90
 
        kdc_config_len = strlen(kdc_config);
91
 
    profile_path = malloc(2 + krb5_config_len + kdc_config_len);
92
 
    if (profile_path == NULL) {
93
 
        krb5_free_config_files(filenames);
94
 
        return errno;
 
84
        return kret;
 
85
    if (envname == NULL || (kdc_config = getenv(envname)) == NULL)
 
86
        kdc_config = fname;
 
87
    krb5int_buf_init_dynamic(&buf);
 
88
    if (kdc_config)
 
89
        krb5int_buf_add(&buf, kdc_config);
 
90
    for (i = 0; filenames[i] != NULL; i++) {
 
91
        if (krb5int_buf_len(&buf) > 0)
 
92
            krb5int_buf_add(&buf, ":");
 
93
        krb5int_buf_add(&buf, filenames[i]);
95
94
    }
96
 
    if (kdc_config_len)
97
 
        strcpy(profile_path, kdc_config);
98
 
    else
99
 
        profile_path[0] = 0;
100
 
    if (krb5_config_len)
101
 
        for (i = 0; filenames[i] != NULL; i++) {
102
 
            if (kdc_config_len || i)
103
 
                strcat(profile_path, ":");
104
 
            strcat(profile_path, filenames[i]);
105
 
        }
106
95
    krb5_free_config_files(filenames);
 
96
    profile_path = krb5int_buf_data(&buf);
 
97
    if (profile_path == NULL)
 
98
        return ENOMEM;
107
99
    profile = (profile_t) NULL;
108
100
    kret = profile_init_path(profile_path, &profile);
109
101
    free(profile_path);
110
102
    if (kret)
111
 
        return kret;
 
103
        return kret;
112
104
    *acontextp = profile;
113
105
    return 0;
114
106
}
115
107
 
116
108
/*
117
 
 * krb5_aprof_getvals() - Get values from alternate profile.
 
109
 * krb5_aprof_getvals()        - Get values from alternate profile.
118
110
 *
119
111
 * Parameters:
120
 
 *      acontext        - opaque context for alternate profile.
121
 
 *      hierarchy       - hierarchy of value to retrieve.
122
 
 *      retdata         - Returned data values.
 
112
 *        acontext        - opaque context for alternate profile.
 
113
 *        hierarchy        - hierarchy of value to retrieve.
 
114
 *        retdata                - Returned data values.
123
115
 *
124
116
 * Returns:
125
 
 *      error codes from profile_get_values()
 
117
 *         error codes from profile_get_values()
126
118
 */
127
119
krb5_error_code
128
120
krb5_aprof_getvals(acontext, hierarchy, retdata)
129
 
    krb5_pointer        acontext;
130
 
    const char          **hierarchy;
131
 
    char                ***retdata;
 
121
    krb5_pointer        acontext;
 
122
    const char          **hierarchy;
 
123
    char                ***retdata;
132
124
{
133
125
    return(profile_get_values((profile_t) acontext,
134
 
                              hierarchy,
135
 
                              retdata));
 
126
                              hierarchy,
 
127
                              retdata));
136
128
}
137
129
 
138
130
/*
139
131
 * krb5_aprof_get_boolean()
140
132
 *
141
133
 * Parameters:
142
 
 *      acontext        - opaque context for alternate profile
143
 
 *      hierarchy       - hierarchy of value to retrieve
144
 
 *      retdata         - Returned data value
 
134
 *        acontext        - opaque context for alternate profile
 
135
 *        hierarchy        - hierarchy of value to retrieve
 
136
 *        retdata                - Returned data value
145
137
 * Returns:
146
 
 *      error codes
 
138
 *        error codes
147
139
 */
148
140
 
149
141
static krb5_error_code
151
143
{
152
144
    static const char *const yes[] = { "y", "yes", "true", "t", "1", "on" };
153
145
    static const char *const no[] = { "n", "no", "false", "f", "nil", "0", "off" };
154
 
    int i;
 
146
    unsigned int i;
155
147
 
156
148
    for (i = 0; i < sizeof(yes)/sizeof(yes[0]); i++)
157
 
        if (!strcasecmp(string, yes[i])) {
158
 
            *out = 1;
159
 
            return 0;
160
 
        }
 
149
        if (!strcasecmp(string, yes[i])) {
 
150
            *out = 1;
 
151
            return 0;
 
152
        }
161
153
    for (i = 0; i < sizeof(no)/sizeof(no[0]); i++)
162
 
        if (!strcasecmp(string, no[i])) {
163
 
            *out = 0;
164
 
            return 0;
165
 
        }
 
154
        if (!strcasecmp(string, no[i])) {
 
155
            *out = 0;
 
156
            return 0;
 
157
        }
166
158
    return PROF_BAD_BOOLEAN;
167
159
}
168
160
 
169
161
krb5_error_code
170
162
krb5_aprof_get_boolean(krb5_pointer acontext, const char **hierarchy,
171
 
                       int uselast, krb5_boolean *retdata)
 
163
                       int uselast, krb5_boolean *retdata)
172
164
{
173
165
    krb5_error_code kret;
174
166
    char **values;
178
170
 
179
171
    kret = krb5_aprof_getvals (acontext, hierarchy, &values);
180
172
    if (kret)
181
 
        return kret;
 
173
        return kret;
182
174
    idx = 0;
183
175
    if (uselast) {
184
 
        while (values[idx])
185
 
            idx++;
186
 
        idx--;
 
176
        while (values[idx])
 
177
            idx++;
 
178
        idx--;
187
179
    }
188
180
    valp = values[idx];
189
181
    kret = string_to_boolean (valp, &val);
 
182
    profile_free_list(values);
190
183
    if (kret)
191
 
        return kret;
 
184
        return kret;
192
185
    *retdata = val;
193
186
    return 0;
194
187
}
195
188
 
196
189
/*
197
 
 * krb5_aprof_get_deltat()      - Get a delta time value from the alternate
198
 
 *                                profile.
 
190
 * krb5_aprof_get_deltat()        - Get a delta time value from the alternate
 
191
 *                                  profile.
199
192
 *
200
193
 * Parameters:
201
 
 *      acontext                - opaque context for alternate profile.
202
 
 *      hierarchy               - hierarchy of value to retrieve.
203
 
 *      uselast                 - if true, use last value, otherwise use
204
 
 *                                first value found.
205
 
 *      deltatp                 - returned delta time value.
 
194
 *        acontext                 - opaque context for alternate profile.
 
195
 *        hierarchy                - hierarchy of value to retrieve.
 
196
 *        uselast                  - if true, use last value, otherwise use
 
197
 *                                   first value found.
 
198
 *        deltatp                  - returned delta time value.
206
199
 *
207
200
 * Returns:
208
 
 *      error codes from profile_get_values()
209
 
 *      error codes from krb5_string_to_deltat()
 
201
 *         error codes from profile_get_values()
 
202
 *        error codes from krb5_string_to_deltat()
210
203
 */
211
204
krb5_error_code
212
205
krb5_aprof_get_deltat(acontext, hierarchy, uselast, deltatp)
213
 
    krb5_pointer        acontext;
214
 
    const char          **hierarchy;
215
 
    krb5_boolean        uselast;
216
 
    krb5_deltat         *deltatp;
 
206
    krb5_pointer        acontext;
 
207
    const char          **hierarchy;
 
208
    krb5_boolean        uselast;
 
209
    krb5_deltat         *deltatp;
217
210
{
218
 
    krb5_error_code     kret;
219
 
    char                **values;
220
 
    char                *valp;
221
 
    int                 idx;
 
211
    krb5_error_code     kret;
 
212
    char                **values;
 
213
    char                *valp;
 
214
    int                 idx;
222
215
 
223
216
    if (!(kret = krb5_aprof_getvals(acontext, hierarchy, &values))) {
224
 
        idx = 0;
225
 
        if (uselast) {
226
 
            for (idx=0; values[idx]; idx++);
227
 
            idx--;
228
 
        }
229
 
        valp = values[idx];
230
 
        kret = krb5_string_to_deltat(valp, deltatp);
 
217
        idx = 0;
 
218
        if (uselast) {
 
219
            for (idx=0; values[idx]; idx++);
 
220
            idx--;
 
221
        }
 
222
        valp = values[idx];
 
223
        kret = krb5_string_to_deltat(valp, deltatp);
231
224
 
232
 
        /* Free the string storage */
233
 
        for (idx=0; values[idx]; idx++)
234
 
            krb5_xfree(values[idx]);
235
 
        krb5_xfree(values);
 
225
        /* Free the string storage */
 
226
        profile_free_list(values);
236
227
    }
237
228
    return(kret);
238
229
}
239
230
 
240
231
/*
241
 
 * krb5_aprof_get_string()      - Get a string value from the alternate
242
 
 *                                profile.
 
232
 * krb5_aprof_get_string()        - Get a string value from the alternate
 
233
 *                                  profile.
243
234
 *
244
235
 * Parameters:
245
 
 *      acontext                - opaque context for alternate profile.
246
 
 *      hierarchy               - hierarchy of value to retrieve.
247
 
 *      uselast                 - if true, use last value, otherwise use
248
 
 *                                first value found.
249
 
 *      stringp                 - returned string value.
 
236
 *        acontext                 - opaque context for alternate profile.
 
237
 *        hierarchy                - hierarchy of value to retrieve.
 
238
 *        uselast                  - if true, use last value, otherwise use
 
239
 *                                   first value found.
 
240
 *        stringp                  - returned string value.
250
241
 *
251
242
 * Returns:
252
 
 *      error codes from profile_get_values()
 
243
 *         error codes from profile_get_values()
253
244
 */
254
245
krb5_error_code
255
246
krb5_aprof_get_string(acontext, hierarchy, uselast, stringp)
256
 
    krb5_pointer        acontext;
257
 
    const char          **hierarchy;
258
 
    krb5_boolean        uselast;
259
 
    char                **stringp;
 
247
    krb5_pointer        acontext;
 
248
    const char          **hierarchy;
 
249
    krb5_boolean        uselast;
 
250
    char                **stringp;
260
251
{
261
 
    krb5_error_code     kret;
262
 
    char                **values;
263
 
    int                 idx, i;
 
252
    krb5_error_code     kret;
 
253
    char                **values;
 
254
    int                 lastidx;
264
255
 
265
256
    if (!(kret = krb5_aprof_getvals(acontext, hierarchy, &values))) {
266
 
        idx = 0;
267
 
        if (uselast) {
268
 
            for (idx=0; values[idx]; idx++);
269
 
            idx--;
270
 
        }
271
 
 
272
 
        *stringp = values[idx];
273
 
 
274
 
        /* Free the string storage */
275
 
        for (i=0; values[i]; i++)
276
 
            if (i != idx)
277
 
                krb5_xfree(values[i]);
278
 
        krb5_xfree(values);
 
257
        for (lastidx=0; values[lastidx]; lastidx++);
 
258
        lastidx--;
 
259
 
 
260
        /* Excise the entry we want from the null-terminated list,
 
261
           and free up the rest.  */
 
262
        if (uselast) {
 
263
            *stringp = values[lastidx];
 
264
            values[lastidx] = NULL;
 
265
        } else {
 
266
            *stringp = values[0];
 
267
            values[0] = values[lastidx];
 
268
            values[lastidx] = NULL;
 
269
        }
 
270
 
 
271
        /* Free the string storage */
 
272
        profile_free_list(values);
279
273
    }
280
274
    return(kret);
281
275
}
282
276
 
283
277
/*
284
 
 * krb5_aprof_get_int32()       - Get a 32-bit integer value from the alternate
285
 
 *                                profile.
286
 
 *
287
 
 * Parameters:
288
 
 *      acontext                - opaque context for alternate profile.
289
 
 *      hierarchy               - hierarchy of value to retrieve.
290
 
 *      uselast                 - if true, use last value, otherwise use
291
 
 *                                first value found.
292
 
 *      intp                    - returned 32-bit integer value.
293
 
 *
294
 
 * Returns:
295
 
 *      error codes from profile_get_values()
296
 
 *      EINVAL                  - value is not an integer
 
278
 * krb5_aprof_get_string_all()  - When the attr identified by "hierarchy" is specified multiple times, 
 
279
 *                                collect all its string values from the alternate  profile. 
 
280
 *
 
281
 * Parameters:
 
282
 *        acontext                 - opaque context for alternate profile.
 
283
 *        hierarchy                - hierarchy of value to retrieve.
 
284
 *        stringp                  - Returned string value.
 
285
 *
 
286
 * Returns:
 
287
 *         error codes from profile_get_values() or ENOMEM
 
288
 *         Caller is responsible for deallocating stringp buffer
 
289
 */
 
290
krb5_error_code
 
291
krb5_aprof_get_string_all(acontext, hierarchy, stringp)
 
292
    krb5_pointer        acontext;
 
293
    const char          **hierarchy;
 
294
    char                **stringp;
 
295
{
 
296
    krb5_error_code     kret=0;
 
297
    char                **values;
 
298
    int                 lastidx = 0;
 
299
    char                *tmp = NULL ;
 
300
    size_t              buf_size = 0; 
 
301
    kret = krb5_aprof_getvals(acontext, hierarchy, &values);
 
302
    if (!kret) {
 
303
        for (lastidx=0; values[lastidx]; lastidx++);
 
304
        lastidx--;
 
305
         
 
306
        buf_size = strlen(values[0])+3;
 
307
        for (lastidx=1; values[lastidx]; lastidx++){
 
308
            buf_size += strlen(values[lastidx]) + 3;
 
309
         }
 
310
    }
 
311
    if (buf_size > 0) {
 
312
        *stringp = calloc(1,buf_size);
 
313
        if (*stringp == NULL){
 
314
            profile_free_list(values);
 
315
            return ENOMEM;
 
316
        }
 
317
        tmp=*stringp;
 
318
        strlcpy(tmp, values[0], buf_size);
 
319
        for (lastidx=1; values[lastidx]; lastidx++){
 
320
            tmp = strcat(tmp, " ");
 
321
            tmp = strcat(tmp, values[lastidx]);
 
322
         }
 
323
        /* Free the string storage */
 
324
        profile_free_list(values);
 
325
    }
 
326
    return(kret);
 
327
} 
 
328
 
 
329
 
 
330
/*
 
331
 * krb5_aprof_get_int32()        - Get a 32-bit integer value from the alternate
 
332
 *                                  profile.
 
333
 *
 
334
 * Parameters:
 
335
 *        acontext                 - opaque context for alternate profile.
 
336
 *        hierarchy                - hierarchy of value to retrieve.
 
337
 *        uselast                  - if true, use last value, otherwise use
 
338
 *                                   first value found.
 
339
 *        intp                     - returned 32-bit integer value.
 
340
 *
 
341
 * Returns:
 
342
 *        error codes from profile_get_values()
 
343
 *        EINVAL                        - value is not an integer
297
344
 */
298
345
krb5_error_code
299
346
krb5_aprof_get_int32(acontext, hierarchy, uselast, intp)
300
 
    krb5_pointer        acontext;
301
 
    const char          **hierarchy;
302
 
    krb5_boolean        uselast;
303
 
    krb5_int32          *intp;
 
347
    krb5_pointer        acontext;
 
348
    const char          **hierarchy;
 
349
    krb5_boolean        uselast;
 
350
    krb5_int32          *intp;
304
351
{
305
 
    krb5_error_code     kret;
306
 
    char                **values;
307
 
    int                 idx;
 
352
    krb5_error_code     kret;
 
353
    char                **values;
 
354
    int                 idx;
308
355
 
309
356
    if (!(kret = krb5_aprof_getvals(acontext, hierarchy, &values))) {
310
 
        idx = 0;
311
 
        if (uselast) {
312
 
            for (idx=0; values[idx]; idx++);
313
 
            idx--;
314
 
        }
315
 
 
316
 
        if (sscanf(values[idx], "%d", intp) != 1)
317
 
            kret = EINVAL;
318
 
 
319
 
        /* Free the string storage */
320
 
        for (idx=0; values[idx]; idx++)
321
 
            krb5_xfree(values[idx]);
322
 
        krb5_xfree(values);
 
357
        idx = 0;
 
358
        if (uselast) {
 
359
            for (idx=0; values[idx]; idx++);
 
360
            idx--;
 
361
        }
 
362
 
 
363
        if (sscanf(values[idx], "%d", intp) != 1)
 
364
            kret = EINVAL;
 
365
 
 
366
        /* Free the string storage */
 
367
        profile_free_list(values);
323
368
    }
324
369
    return(kret);
325
370
}
326
371
 
327
372
/*
328
 
 * krb5_aprof_finish()  - Finish alternate profile context.
 
373
 * krb5_aprof_finish()    - Finish alternate profile context.
329
374
 *
330
375
 * Parameter:
331
 
 *      acontext        - opaque context for alternate profile.
 
376
 *        acontext        - opaque context for alternate profile.
332
377
 *
333
378
 * Returns:
334
 
 *      0 on success, something else on failure.
 
379
 *        0 on success, something else on failure.
335
380
 */
336
381
krb5_error_code
337
382
krb5_aprof_finish(acontext)
338
 
    krb5_pointer        acontext;
 
383
    krb5_pointer        acontext;
339
384
{
340
385
    profile_release(acontext);
341
386
    return(0);
342
387
}
343
388
 
344
389
/*
 
390
 * Returns nonzero if it found something to copy; the caller may still
 
391
 * need to check the output field or mask to see if the copy
 
392
 * (allocation) was successful.  Returns zero if nothing was found to
 
393
 * copy, and thus the caller may want to apply some default heuristic.
 
394
 * If the default action is just to use a fixed, compiled-in string,
 
395
 * supply it as the default value here and ignore the return value.
 
396
 */
 
397
static int
 
398
get_string_param(char **param_out, char *param_in,
 
399
                 long *mask_out, long mask_in, long mask_bit,
 
400
                 krb5_pointer aprofile,
 
401
                 const char **hierarchy,
 
402
                 const char *config_name,
 
403
                 const char *default_value)
 
404
{
 
405
    char *svalue;
 
406
 
 
407
    hierarchy[2] = config_name;
 
408
    if (mask_in & mask_bit) {
 
409
        *param_out = strdup(param_in);
 
410
        if (*param_out)
 
411
            *mask_out |= mask_bit;
 
412
        return 1;
 
413
    } else if (aprofile &&
 
414
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
 
415
        *param_out = svalue;
 
416
        *mask_out |= mask_bit;
 
417
        return 1;
 
418
    } else if (default_value) {
 
419
        *param_out = strdup(default_value);
 
420
        if (*param_out)
 
421
            *mask_out |= mask_bit;
 
422
        return 1;
 
423
    } else {
 
424
        return 0;
 
425
    }
 
426
}
 
427
/*
 
428
 * Similar, for (host-order) port number, if not already set in the
 
429
 * output field; default_value==0 means no default.
 
430
 */
 
431
static void
 
432
get_port_param(int *param_out, int param_in,
 
433
               long *mask_out, long mask_in, long mask_bit,
 
434
               krb5_pointer aprofile,
 
435
               const char **hierarchy,
 
436
               const char *config_name,
 
437
               int default_value)
 
438
{
 
439
    krb5_int32 ivalue;
 
440
 
 
441
    if (! (*mask_out & mask_bit)) {
 
442
        hierarchy[2] = config_name;
 
443
        if (mask_in & mask_bit) {
 
444
            *mask_out |= mask_bit;
 
445
            *param_out = param_in;
 
446
        } else if (aprofile &&
 
447
                   !krb5_aprof_get_int32(aprofile, hierarchy, TRUE, &ivalue)) {
 
448
            *param_out = ivalue;
 
449
            *mask_out |= mask_bit;
 
450
        } else if (default_value) {
 
451
            *param_out = default_value;
 
452
            *mask_out |= mask_bit;
 
453
        }
 
454
    }
 
455
}
 
456
/*
 
457
 * Similar, for delta_t; default is required.
 
458
 */
 
459
static void
 
460
get_deltat_param(krb5_deltat *param_out, krb5_deltat param_in,
 
461
                 long *mask_out, long mask_in, long mask_bit,
 
462
                 krb5_pointer aprofile,
 
463
                 const char **hierarchy,
 
464
                 const char *config_name,
 
465
                 krb5_deltat default_value)
 
466
{
 
467
    krb5_deltat dtvalue;
 
468
 
 
469
    hierarchy[2] = config_name;
 
470
    if (mask_in & mask_bit) {
 
471
        *mask_out |= mask_bit;
 
472
        *param_out = param_in;
 
473
    } else if (aprofile &&
 
474
               !krb5_aprof_get_deltat(aprofile, hierarchy, TRUE, &dtvalue)) {
 
475
        *param_out = dtvalue;
 
476
        *mask_out |= mask_bit;
 
477
    } else {
 
478
        *param_out = default_value;
 
479
        *mask_out |= mask_bit;
 
480
    }
 
481
}
 
482
 
 
483
/*
345
484
 * Function: kadm5_get_config_params
346
485
 *
347
486
 * Purpose: Merge configuration parameters provided by the caller with
349
488
 *
350
489
 * Arguments:
351
490
 *
352
 
 *      context         (r) krb5_context to use
353
 
 *      profile         (r) profile file to use
354
 
 *      envname         (r) envname that contains a profile name to
355
 
 *                      override profile
356
 
 *      params_in       (r) params structure containing user-supplied
357
 
 *                      values, or NULL
358
 
 *      params_out      (w) params structure to be filled in
 
491
 *        context     (r) krb5_context to use
 
492
 *        profile     (r) profile file to use
 
493
 *        envname     (r) envname that contains a profile name to
 
494
 *                        override profile
 
495
 *        params_in   (r) params structure containing user-supplied
 
496
 *                        values, or NULL
 
497
 *        params_out  (w) params structure to be filled in
359
498
 *
360
499
 * Effects:
361
500
 *
370
509
 * versions, overwriting the old pointer value.
371
510
 */
372
511
krb5_error_code kadm5_get_config_params(context, use_kdc_config,
373
 
                                        params_in, params_out)
374
 
   krb5_context         context;
375
 
   int                  use_kdc_config;
376
 
   kadm5_config_params  *params_in, *params_out;
 
512
                                        params_in, params_out)
 
513
   krb5_context               context;
 
514
   int                        use_kdc_config;
 
515
   kadm5_config_params        *params_in, *params_out;
377
516
{
378
 
    char                *filename;
379
 
    char                *envname;
380
 
    char                *lrealm;
381
 
    krb5_pointer        aprofile = 0;
382
 
    const char          *hierarchy[4];
383
 
    char                *svalue;
384
 
    krb5_int32          ivalue;
385
 
    krb5_deltat         dtvalue;
 
517
    char                *filename;
 
518
    char                *envname;
 
519
    char                *lrealm;
 
520
    krb5_pointer        aprofile = 0;
 
521
    const char          *hierarchy[4];
 
522
    char                *svalue;
 
523
    krb5_int32          ivalue;
386
524
    kadm5_config_params params, empty_params;
387
525
 
388
 
    krb5_error_code     kret = 0;
 
526
    krb5_error_code        kret = 0;
389
527
 
390
528
    memset((char *) &params, 0, sizeof(params));
391
529
    memset((char *) &empty_params, 0, sizeof(empty_params));
393
531
    if (params_in == NULL) params_in = &empty_params;
394
532
 
395
533
    if (params_in->mask & KADM5_CONFIG_REALM) {
396
 
         lrealm = params.realm = strdup(params_in->realm);
397
 
         if (params.realm)
398
 
              params.mask |= KADM5_CONFIG_REALM;
 
534
         lrealm = params.realm = strdup(params_in->realm);
 
535
         if (params.realm)
 
536
              params.mask |= KADM5_CONFIG_REALM;
399
537
    } else {
400
 
         kret = krb5_get_default_realm(context, &lrealm);
401
 
         if (kret)
402
 
              goto cleanup;
403
 
         params.realm = lrealm;
404
 
         params.mask |= KADM5_CONFIG_REALM;
 
538
         kret = krb5_get_default_realm(context, &lrealm);
 
539
         if (kret)
 
540
              goto cleanup;
 
541
         params.realm = lrealm;
 
542
         params.mask |= KADM5_CONFIG_REALM;
 
543
    }
 
544
 
 
545
    if (params_in->mask & KADM5_CONFIG_KVNO) {
 
546
        params.kvno = params_in->kvno;
 
547
        params.mask |= KADM5_CONFIG_KVNO;
405
548
    }
406
549
    /*
407
550
     * XXX These defaults should to work on both client and
410
553
     * defaults for NULL values.
411
554
     */
412
555
    if (use_kdc_config) {
413
 
        filename = DEFAULT_KDC_PROFILE;
414
 
        envname = KDC_PROFILE_ENV;
 
556
        filename = DEFAULT_KDC_PROFILE;
 
557
        envname = KDC_PROFILE_ENV;
415
558
    } else {
416
 
        filename = DEFAULT_PROFILE_PATH;
417
 
        envname = "KRB5_CONFIG";
 
559
        filename = DEFAULT_PROFILE_PATH;
 
560
        envname = "KRB5_CONFIG";
418
561
    }
419
562
    if (context->profile_secure == TRUE) envname = 0;
420
563
 
421
564
    kret = krb5_aprof_init(filename, envname, &aprofile);
422
565
    if (kret)
423
 
            goto cleanup;
 
566
            goto cleanup;
424
567
    
425
568
    /* Initialize realm parameters */
426
 
    hierarchy[0] = "realms";
 
569
    hierarchy[0] = KRB5_CONF_REALMS;
427
570
    hierarchy[1] = lrealm;
428
571
    hierarchy[3] = (char *) NULL;
429
572
 
 
573
#define GET_STRING_PARAM(FIELD, BIT, CONFTAG, DEFAULT) \
 
574
    get_string_param(&params.FIELD, params_in->FIELD,  \
 
575
                     &params.mask, params_in->mask, BIT, \
 
576
                     aprofile, hierarchy, CONFTAG, DEFAULT)
 
577
 
430
578
    /* Get the value for the admin server */
431
 
    hierarchy[2] = "admin_server";
432
 
    if (params_in->mask & KADM5_CONFIG_ADMIN_SERVER) {
433
 
         params.admin_server = strdup(params_in->admin_server);
434
 
         if (params.admin_server)
435
 
              params.mask |= KADM5_CONFIG_ADMIN_SERVER;
436
 
    } else if (aprofile &&
437
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
438
 
         params.admin_server = svalue;
439
 
         params.mask |= KADM5_CONFIG_ADMIN_SERVER;
440
 
    }
 
579
    GET_STRING_PARAM(admin_server, KADM5_CONFIG_ADMIN_SERVER, KRB5_CONF_ADMIN_SERVER,
 
580
                     NULL);
 
581
 
441
582
    if (params.mask & KADM5_CONFIG_ADMIN_SERVER) {
442
 
         char *p;
443
 
         p = strchr(params.admin_server, ':');
444
 
         if (p) {
445
 
              params.kadmind_port = atoi(p+1);
446
 
              params.mask |= KADM5_CONFIG_KADMIND_PORT;
447
 
              *p = '\0';
448
 
         }
 
583
         char *p;
 
584
         p = strchr(params.admin_server, ':');
 
585
         if (p) {
 
586
              params.kadmind_port = atoi(p+1);
 
587
              params.mask |= KADM5_CONFIG_KADMIND_PORT;
 
588
              *p = '\0';
 
589
         }
449
590
    }
450
591
 
451
592
    /* Get the value for the database */
452
 
    hierarchy[2] = "database_name";
453
 
    if (params_in->mask & KADM5_CONFIG_DBNAME) {
454
 
         params.dbname = strdup(params_in->dbname);
455
 
         if (params.dbname)
456
 
              params.mask |= KADM5_CONFIG_DBNAME;
457
 
    } else if (aprofile &&
458
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
459
 
         params.dbname = svalue;
460
 
         params.mask |= KADM5_CONFIG_DBNAME;
461
 
    } else {
462
 
         params.dbname = strdup(DEFAULT_KDB_FILE);
463
 
         if (params.dbname) 
464
 
              params.mask |= KADM5_CONFIG_DBNAME;
465
 
    }
466
 
 
467
 
    /*
468
 
     * admin database name and lockfile are now always derived from dbname
469
 
     */
470
 
    if (params.mask & KADM5_CONFIG_DBNAME) {
471
 
         params.admin_dbname = (char *) malloc(strlen(params.dbname) + 7);
472
 
         if (params.admin_dbname) {
473
 
              sprintf(params.admin_dbname, "%s.kadm5", params.dbname);
474
 
              params.mask |= KADM5_CONFIG_ADBNAME;
475
 
         }
476
 
    }
477
 
 
478
 
    if (params.mask & KADM5_CONFIG_ADBNAME) {
479
 
         params.admin_lockfile = (char *) malloc(strlen(params.admin_dbname)
480
 
                                                 + 6);
481
 
         if (params.admin_lockfile) {
482
 
              sprintf(params.admin_lockfile, "%s.lock", params.admin_dbname);
483
 
              params.mask |= KADM5_CONFIG_ADB_LOCKFILE;
484
 
         }
485
 
    }
486
 
    
 
593
    GET_STRING_PARAM(dbname, KADM5_CONFIG_DBNAME, KRB5_CONF_DATABASE_NAME,
 
594
                     DEFAULT_KDB_FILE);
 
595
 
 
596
    params.admin_dbname_was_here = NULL;
 
597
    params.admin_lockfile_was_here = NULL;
 
598
    /* never set KADM5_CONFIG_ADBNAME, KADM5_CONFIG_ADB_LOCKFILE */
 
599
 
487
600
    /* Get the value for the admin (policy) database lock file*/
488
 
    hierarchy[2] = "admin_keytab";
489
 
    if (params_in->mask & KADM5_CONFIG_ADMIN_KEYTAB) {
490
 
         params.admin_keytab = strdup(params_in->admin_keytab);
491
 
         if (params.admin_keytab)
492
 
              params.mask |= KADM5_CONFIG_ADMIN_KEYTAB;
493
 
    } else if (aprofile &&
494
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
495
 
         params.mask |= KADM5_CONFIG_ADMIN_KEYTAB;
496
 
         params.admin_keytab = svalue;
497
 
    } else if ((params.admin_keytab = (char *) getenv("KRB5_KTNAME"))) {
498
 
         params.admin_keytab = strdup(params.admin_keytab);
499
 
         if (params.admin_keytab)
500
 
              params.mask |= KADM5_CONFIG_ADMIN_KEYTAB;
501
 
    } else {
502
 
         params.admin_keytab = strdup(DEFAULT_KADM5_KEYTAB);
503
 
         if (params.admin_keytab)
504
 
              params.mask |= KADM5_CONFIG_ADMIN_KEYTAB;
 
601
    if (!GET_STRING_PARAM(admin_keytab, KADM5_CONFIG_ADMIN_KEYTAB,
 
602
                          KRB5_CONF_ADMIN_KEYTAB, NULL)) {
 
603
        const char *s = getenv("KRB5_KTNAME");
 
604
        if (s == NULL)
 
605
            s = DEFAULT_KADM5_KEYTAB;
 
606
        params.admin_keytab = strdup(s);
 
607
        if (params.admin_keytab)
 
608
            params.mask |= KADM5_CONFIG_ADMIN_KEYTAB;
505
609
    }
506
610
    
507
611
    /* Get the name of the acl file */
508
 
    hierarchy[2] = "acl_file";
509
 
    if (params_in->mask & KADM5_CONFIG_ACL_FILE) {
510
 
         params.acl_file = strdup(params_in->acl_file);
511
 
         if (params.acl_file)
512
 
              params.mask |= KADM5_CONFIG_ACL_FILE;
513
 
    } else if (aprofile &&
514
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
515
 
         params.mask |= KADM5_CONFIG_ACL_FILE;
516
 
         params.acl_file = svalue;
517
 
    } else {
518
 
         params.acl_file = strdup(DEFAULT_KADM5_ACL_FILE);
519
 
         if (params.acl_file)
520
 
              params.mask |= KADM5_CONFIG_ACL_FILE;
521
 
    }
522
 
    
 
612
    GET_STRING_PARAM(acl_file, KADM5_CONFIG_ACL_FILE, KRB5_CONF_ACL_FILE,
 
613
                     DEFAULT_KADM5_ACL_FILE);
 
614
 
523
615
    /* Get the name of the dict file */
524
 
    hierarchy[2] = "dict_file";
525
 
    if (params_in->mask & KADM5_CONFIG_DICT_FILE) {
526
 
         params.dict_file = strdup(params_in->dict_file);
527
 
         if (params.dict_file)
528
 
              params.mask |= KADM5_CONFIG_DICT_FILE;
529
 
    } else if (aprofile &&
530
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
531
 
         params.mask |= KADM5_CONFIG_DICT_FILE;
532
 
         params.dict_file = svalue;
533
 
    }
534
 
            
 
616
    GET_STRING_PARAM(dict_file, KADM5_CONFIG_DICT_FILE, KRB5_CONF_DICT_FILE, NULL);
 
617
 
 
618
#define GET_PORT_PARAM(FIELD, BIT, CONFTAG, DEFAULT) \
 
619
    get_port_param(&params.FIELD, params_in->FIELD,  \
 
620
                   &params.mask, params_in->mask, BIT, \
 
621
                   aprofile, hierarchy, CONFTAG, DEFAULT)
535
622
    /* Get the value for the kadmind port */
536
 
    if (! (params.mask & KADM5_CONFIG_KADMIND_PORT)) {
537
 
         hierarchy[2] = "kadmind_port";
538
 
         if (params_in->mask & KADM5_CONFIG_KADMIND_PORT) {
539
 
              params.mask |= KADM5_CONFIG_KADMIND_PORT;
540
 
              params.kadmind_port = params_in->kadmind_port;
541
 
         } else if (aprofile &&
542
 
                    !krb5_aprof_get_int32(aprofile, hierarchy, TRUE,
543
 
                                          &ivalue)) { 
544
 
              params.kadmind_port = ivalue;
545
 
              params.mask |= KADM5_CONFIG_KADMIND_PORT;
546
 
         } else {
547
 
              params.kadmind_port = DEFAULT_KADM5_PORT;
548
 
              params.mask |= KADM5_CONFIG_KADMIND_PORT;
549
 
         }
550
 
    }
551
 
    
 
623
    GET_PORT_PARAM(kadmind_port, KADM5_CONFIG_KADMIND_PORT,
 
624
                   KRB5_CONF_KADMIND_PORT, DEFAULT_KADM5_PORT);
 
625
 
552
626
    /* Get the value for the kpasswd port */
553
 
    if (! (params.mask & KADM5_CONFIG_KPASSWD_PORT)) {
554
 
        hierarchy[2] = "kpasswd_port";
555
 
        if (params_in->mask & KADM5_CONFIG_KPASSWD_PORT) {
556
 
            params.mask |= KADM5_CONFIG_KPASSWD_PORT;
557
 
            params.kpasswd_port = params_in->kpasswd_port;
558
 
        } else if (aprofile &&
559
 
                   !krb5_aprof_get_int32(aprofile, hierarchy, TRUE,
560
 
                                         &ivalue)) { 
561
 
            params.kpasswd_port = ivalue;
562
 
            params.mask |= KADM5_CONFIG_KPASSWD_PORT;
563
 
        } else {
564
 
            params.kpasswd_port = DEFAULT_KPASSWD_PORT;
565
 
            params.mask |= KADM5_CONFIG_KPASSWD_PORT;
566
 
        }
567
 
    }
568
 
    
 
627
    GET_PORT_PARAM(kpasswd_port, KADM5_CONFIG_KPASSWD_PORT,
 
628
                   KRB5_CONF_KPASSWD_PORT, DEFAULT_KPASSWD_PORT);
 
629
 
569
630
    /* Get the value for the master key name */
570
 
         hierarchy[2] = "master_key_name";
571
 
    if (params_in->mask & KADM5_CONFIG_MKEY_NAME) {
572
 
         params.mkey_name = strdup(params_in->mkey_name);
573
 
         if (params.mkey_name)
574
 
              params.mask |= KADM5_CONFIG_MKEY_NAME;
575
 
    } else if (aprofile &&
576
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
577
 
         params.mask |= KADM5_CONFIG_MKEY_NAME;
578
 
         params.mkey_name = svalue;
579
 
    }
580
 
    
 
631
    GET_STRING_PARAM(mkey_name, KADM5_CONFIG_MKEY_NAME,
 
632
                     KRB5_CONF_MASTER_KEY_NAME, NULL);
 
633
 
581
634
    /* Get the value for the master key type */
582
 
    hierarchy[2] = "master_key_type";
 
635
    hierarchy[2] = KRB5_CONF_MASTER_KEY_TYPE;
583
636
    if (params_in->mask & KADM5_CONFIG_ENCTYPE) {
584
 
         params.mask |= KADM5_CONFIG_ENCTYPE;
585
 
         params.enctype = params_in->enctype;
 
637
         params.mask |= KADM5_CONFIG_ENCTYPE;
 
638
         params.enctype = params_in->enctype;
586
639
    } else if (aprofile &&
587
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
588
 
         if (!krb5_string_to_enctype(svalue, &params.enctype)) {
589
 
              params.mask |= KADM5_CONFIG_ENCTYPE;
590
 
              krb5_xfree(svalue);
591
 
         }
 
640
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
 
641
         if (!krb5_string_to_enctype(svalue, &params.enctype)) {
 
642
              params.mask |= KADM5_CONFIG_ENCTYPE;
 
643
              free(svalue);
 
644
         }
592
645
    } else {
593
 
         params.mask |= KADM5_CONFIG_ENCTYPE;
594
 
         params.enctype = DEFAULT_KDC_ENCTYPE;
 
646
         params.mask |= KADM5_CONFIG_ENCTYPE;
 
647
         params.enctype = DEFAULT_KDC_ENCTYPE;
595
648
    }
596
649
    
597
650
    /* Get the value for mkey_from_kbd */
598
651
    if (params_in->mask & KADM5_CONFIG_MKEY_FROM_KBD) {
599
 
         params.mask |= KADM5_CONFIG_MKEY_FROM_KBD;
600
 
         params.mkey_from_kbd = params_in->mkey_from_kbd;
 
652
         params.mask |= KADM5_CONFIG_MKEY_FROM_KBD;
 
653
         params.mkey_from_kbd = params_in->mkey_from_kbd;
601
654
    }
602
655
    
603
656
    /* Get the value for the stashfile */
604
 
    hierarchy[2] = "key_stash_file";
605
 
    if (params_in->mask & KADM5_CONFIG_STASH_FILE) {
606
 
         params.stash_file = strdup(params_in->stash_file);
607
 
         if (params.stash_file)
608
 
              params.mask |= KADM5_CONFIG_STASH_FILE;
609
 
    } else if (aprofile &&
610
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
611
 
         params.mask |= KADM5_CONFIG_STASH_FILE;
612
 
         params.stash_file = svalue;
613
 
    }
 
657
    GET_STRING_PARAM(stash_file, KADM5_CONFIG_STASH_FILE,
 
658
                     KRB5_CONF_KEY_STASH_FILE, NULL);
614
659
 
615
660
    /* Get the value for maximum ticket lifetime. */
616
 
    hierarchy[2] = "max_life";
617
 
    if (params_in->mask & KADM5_CONFIG_MAX_LIFE) {
618
 
         params.mask |= KADM5_CONFIG_MAX_LIFE;
619
 
         params.max_life = params_in->max_life;
620
 
    } else if (aprofile &&
621
 
               !krb5_aprof_get_deltat(aprofile, hierarchy, TRUE, &dtvalue)) {
622
 
         params.max_life = dtvalue;
623
 
         params.mask |= KADM5_CONFIG_MAX_LIFE;
624
 
    } else {
625
 
         params.max_life = 24 * 60 * 60; /* 1 day */
626
 
         params.mask |= KADM5_CONFIG_MAX_LIFE;
627
 
    }    
628
 
            
 
661
#define GET_DELTAT_PARAM(FIELD, BIT, CONFTAG, DEFAULT) \
 
662
    get_deltat_param(&params.FIELD, params_in->FIELD,  \
 
663
                     &params.mask, params_in->mask, BIT, \
 
664
                     aprofile, hierarchy, CONFTAG, DEFAULT)
 
665
 
 
666
    GET_DELTAT_PARAM(max_life, KADM5_CONFIG_MAX_LIFE, KRB5_CONF_MAX_LIFE,
 
667
                     24 * 60 * 60); /* 1 day */
 
668
 
629
669
    /* Get the value for maximum renewable ticket lifetime. */
630
 
    hierarchy[2] = "max_renewable_life";
631
 
    if (params_in->mask & KADM5_CONFIG_MAX_RLIFE) {
632
 
         params.mask |= KADM5_CONFIG_MAX_RLIFE;
633
 
         params.max_rlife = params_in->max_rlife;
634
 
    } else if (aprofile &&
635
 
               !krb5_aprof_get_deltat(aprofile, hierarchy, TRUE, &dtvalue)) {
636
 
         params.max_rlife = dtvalue;
637
 
         params.mask |= KADM5_CONFIG_MAX_RLIFE;
638
 
    } else {
639
 
         params.max_rlife = 0;
640
 
         params.mask |= KADM5_CONFIG_MAX_RLIFE;
641
 
    }
642
 
            
 
670
    GET_DELTAT_PARAM(max_rlife, KADM5_CONFIG_MAX_RLIFE, KRB5_CONF_MAX_RENEWABLE_LIFE,
 
671
                     0);
 
672
 
643
673
    /* Get the value for the default principal expiration */
644
 
    hierarchy[2] = "default_principal_expiration";
 
674
    hierarchy[2] = KRB5_CONF_DEFAULT_PRINCIPAL_EXPIRATION;
645
675
    if (params_in->mask & KADM5_CONFIG_EXPIRATION) {
646
 
         params.mask |= KADM5_CONFIG_EXPIRATION;
647
 
         params.expiration = params_in->expiration;
 
676
         params.mask |= KADM5_CONFIG_EXPIRATION;
 
677
         params.expiration = params_in->expiration;
648
678
    } else if (aprofile &&
649
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
650
 
         if (!krb5_string_to_timestamp(svalue, &params.expiration)) {
651
 
              params.mask |= KADM5_CONFIG_EXPIRATION;
652
 
              krb5_xfree(svalue);
653
 
         }
 
679
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
 
680
         if (!krb5_string_to_timestamp(svalue, &params.expiration)) {
 
681
              params.mask |= KADM5_CONFIG_EXPIRATION;
 
682
              free(svalue);
 
683
         }
654
684
    } else {
655
 
         params.mask |= KADM5_CONFIG_EXPIRATION;
656
 
         params.expiration = 0;
 
685
         params.mask |= KADM5_CONFIG_EXPIRATION;
 
686
         params.expiration = 0;
657
687
    }
658
688
    
659
689
    /* Get the value for the default principal flags */
660
 
    hierarchy[2] = "default_principal_flags";
 
690
    hierarchy[2] = KRB5_CONF_DEFAULT_PRINCIPAL_FLAGS;
661
691
    if (params_in->mask & KADM5_CONFIG_FLAGS) {
662
 
         params.mask |= KADM5_CONFIG_FLAGS;
663
 
         params.flags = params_in->flags;
 
692
         params.mask |= KADM5_CONFIG_FLAGS;
 
693
         params.flags = params_in->flags;
664
694
    } else if (aprofile &&
665
 
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
666
 
         char *sp, *ep, *tp;
667
 
         
668
 
         sp = svalue;
669
 
         params.flags = 0;
670
 
         while (sp) {
671
 
              if ((ep = strchr(sp, (int) ',')) ||
672
 
                  (ep = strchr(sp, (int) ' ')) ||
673
 
                  (ep = strchr(sp, (int) '\t'))) {
674
 
                   /* Fill in trailing whitespace of sp */
675
 
                   tp = ep - 1;
676
 
                   while (isspace((int) *tp) && (tp > sp)) {
677
 
                        *tp = '\0';
678
 
                        tp--;
679
 
                   }
680
 
                   *ep = '\0';
681
 
                   ep++;
682
 
                   /* Skip over trailing whitespace of ep */
683
 
                   while (isspace((int) *ep) && (*ep)) ep++;
684
 
              }
685
 
              /* Convert this flag */
686
 
              if (krb5_string_to_flags(sp,
687
 
                                       "+",
688
 
                                       "-",
689
 
                                       &params.flags))
690
 
                   break;
691
 
              sp = ep;
692
 
         }
693
 
         if (!sp)
694
 
              params.mask |= KADM5_CONFIG_FLAGS;
695
 
         krb5_xfree(svalue);
 
695
               !krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
 
696
         char *sp, *ep, *tp;
 
697
         
 
698
         sp = svalue;
 
699
         params.flags = 0;
 
700
         while (sp) {
 
701
              if ((ep = strchr(sp, (int) ',')) ||
 
702
                  (ep = strchr(sp, (int) ' ')) ||
 
703
                  (ep = strchr(sp, (int) '\t'))) {
 
704
                   /* Fill in trailing whitespace of sp */
 
705
                   tp = ep - 1;
 
706
                   while (isspace((int) *tp) && (tp > sp)) {
 
707
                        *tp = '\0';
 
708
                        tp--;
 
709
                   }
 
710
                   *ep = '\0';
 
711
                   ep++;
 
712
                   /* Skip over trailing whitespace of ep */
 
713
                   while (isspace((int) *ep) && (*ep)) ep++;
 
714
              }
 
715
              /* Convert this flag */
 
716
              if (krb5_string_to_flags(sp,
 
717
                                       "+",
 
718
                                       "-",
 
719
                                       &params.flags))
 
720
                   break;
 
721
              sp = ep;
 
722
         }
 
723
         if (!sp)
 
724
              params.mask |= KADM5_CONFIG_FLAGS;
 
725
         free(svalue);
696
726
    } else {
697
 
         params.mask |= KADM5_CONFIG_FLAGS;
698
 
         params.flags = KRB5_KDB_DEF_FLAGS;
 
727
         params.mask |= KADM5_CONFIG_FLAGS;
 
728
         params.flags = KRB5_KDB_DEF_FLAGS;
699
729
    }
700
730
 
701
731
    /* Get the value for the supported enctype/salttype matrix */
702
 
    hierarchy[2] = "supported_enctypes";
 
732
    hierarchy[2] = KRB5_CONF_SUPPORTED_ENCTYPES;
703
733
    if (params_in->mask & KADM5_CONFIG_ENCTYPES) {
704
734
         /* The following scenario is when the input keysalts are !NULL */
705
735
         if(params_in->keysalts) {
706
 
               params.keysalts = copy_key_salt_tuple(params_in->keysalts, 
707
 
                                                     params_in->num_keysalts);
708
 
               if(params.keysalts) {
709
 
                 params.mask |= KADM5_CONFIG_ENCTYPES;
710
 
                 params.num_keysalts = params_in->num_keysalts;
711
 
               }
712
 
         } else {
713
 
                 params.mask |= KADM5_CONFIG_ENCTYPES;
714
 
                 params.keysalts = 0;
715
 
                 params.num_keysalts = params_in->num_keysalts;
716
 
         }
 
736
               params.keysalts = copy_key_salt_tuple(params_in->keysalts, 
 
737
                                                     params_in->num_keysalts);
 
738
               if(params.keysalts) {
 
739
                 params.mask |= KADM5_CONFIG_ENCTYPES;
 
740
                 params.num_keysalts = params_in->num_keysalts;
 
741
               }
 
742
         } else {
 
743
                 params.mask |= KADM5_CONFIG_ENCTYPES;
 
744
                 params.keysalts = 0;
 
745
                 params.num_keysalts = params_in->num_keysalts;
 
746
         }
717
747
    } else {
718
 
         svalue = NULL;
719
 
         if (aprofile)
720
 
              krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue);
721
 
         if (svalue == NULL)
722
 
             svalue = strdup("des3-hmac-sha1:normal des-cbc-crc:normal");
723
 
 
724
 
         params.keysalts = NULL;
725
 
         params.num_keysalts = 0;
726
 
         krb5_string_to_keysalts(svalue,
727
 
                                 ", \t",/* Tuple separators     */
728
 
                                 ":.-", /* Key/salt separators  */
729
 
                                 0,     /* No duplicates        */
730
 
                                 &params.keysalts,
731
 
                                 &params.num_keysalts);
732
 
         if (params.num_keysalts)
733
 
              params.mask |= KADM5_CONFIG_ENCTYPES;
734
 
 
735
 
         if (svalue)
736
 
              krb5_xfree(svalue);
 
748
         svalue = NULL;
 
749
         if (aprofile)
 
750
              krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue);
 
751
         if (svalue == NULL)
 
752
             svalue = strdup(KRB5_DEFAULT_SUPPORTED_ENCTYPES);
 
753
 
 
754
         params.keysalts = NULL;
 
755
         params.num_keysalts = 0;
 
756
         krb5_string_to_keysalts(svalue,
 
757
                                 ", \t",/* Tuple separators */
 
758
                                 ":.-",        /* Key/salt separators */
 
759
                                 0,        /* No duplicates */
 
760
                                 &params.keysalts,
 
761
                                 &params.num_keysalts);
 
762
         if (params.num_keysalts)
 
763
              params.mask |= KADM5_CONFIG_ENCTYPES;
 
764
 
 
765
         free(svalue);
737
766
    }
738
767
    
 
768
        hierarchy[2] = KRB5_CONF_IPROP_ENABLE;
 
769
 
 
770
        params.iprop_enabled = FALSE;
 
771
        params.mask |= KADM5_CONFIG_IPROP_ENABLED;
 
772
 
 
773
        if (params_in->mask & KADM5_CONFIG_IPROP_ENABLED) {
 
774
                params.mask |= KADM5_CONFIG_IPROP_ENABLED;
 
775
                params.iprop_enabled = params_in->iprop_enabled;
 
776
        } else {
 
777
                krb5_boolean bvalue;
 
778
                if (aprofile &&
 
779
                    !krb5_aprof_get_boolean(aprofile, hierarchy, TRUE, &bvalue)) {
 
780
                    params.iprop_enabled = bvalue;
 
781
                    params.mask |= KADM5_CONFIG_IPROP_ENABLED;
 
782
                }
 
783
        }
 
784
 
 
785
        if (!GET_STRING_PARAM(iprop_logfile, KADM5_CONFIG_IPROP_LOGFILE,
 
786
                              KRB5_CONF_IPROP_LOGFILE, NULL)) {
 
787
            if (params.mask & KADM5_CONFIG_DBNAME) {
 
788
                if (asprintf(&params.iprop_logfile, "%s.ulog", params.dbname) >= 0) {
 
789
                    params.mask |= KADM5_CONFIG_IPROP_LOGFILE;
 
790
                }
 
791
            }
 
792
        }
 
793
 
 
794
        GET_PORT_PARAM(iprop_port, KADM5_CONFIG_IPROP_PORT,
 
795
                       KRB5_CONF_IPROP_PORT, 0);
 
796
 
 
797
        hierarchy[2] = KRB5_CONF_IPROP_MASTER_ULOGSIZE;
 
798
 
 
799
        params.iprop_ulogsize = DEF_ULOGENTRIES;
 
800
        params.mask |= KADM5_CONFIG_ULOG_SIZE;
 
801
 
 
802
        if (params_in->mask & KADM5_CONFIG_ULOG_SIZE) {
 
803
                params.mask |= KADM5_CONFIG_ULOG_SIZE;
 
804
                params.iprop_ulogsize = params_in->iprop_ulogsize;
 
805
        } else {
 
806
                if (aprofile && !krb5_aprof_get_int32(aprofile, hierarchy,
 
807
                    TRUE, &ivalue)) {
 
808
                        if (ivalue > MAX_ULOGENTRIES)
 
809
                                params.iprop_ulogsize = MAX_ULOGENTRIES;
 
810
                        else if (ivalue <= 0)
 
811
                                params.iprop_ulogsize = DEF_ULOGENTRIES;
 
812
                        else
 
813
                                params.iprop_ulogsize = ivalue;
 
814
                        params.mask |= KADM5_CONFIG_ULOG_SIZE;
 
815
                }
 
816
        }
 
817
 
 
818
        GET_DELTAT_PARAM(iprop_poll_time, KADM5_CONFIG_POLL_TIME,
 
819
                         KRB5_CONF_IPROP_SLAVE_POLL, 2 * 60); /* 2m */
 
820
 
739
821
    *params_out = params;
740
822
    
741
823
cleanup:
742
824
    if (aprofile)
743
 
        krb5_aprof_finish(aprofile);
 
825
        krb5_aprof_finish(aprofile);
744
826
    if (kret) {
745
 
         kadm5_free_config_params(context, &params);
746
 
         params_out->mask = 0;
 
827
         kadm5_free_config_params(context, &params);
 
828
         params_out->mask = 0;
747
829
    }
748
830
    return(kret);
749
831
}
750
832
/*
751
 
 * kadm5_free_config_params()   - Free data allocated by above.
 
833
 * kadm5_free_config_params()        - Free data allocated by above.
752
834
 */
753
835
krb5_error_code
754
836
kadm5_free_config_params(context, params)
755
 
    krb5_context        context;
756
 
    kadm5_config_params *params;
 
837
    krb5_context        context;
 
838
    kadm5_config_params        *params;
757
839
{
758
840
    if (params) {
759
 
        if (params->dbname)
760
 
            krb5_xfree(params->dbname);
761
 
        if (params->mkey_name)
762
 
            krb5_xfree(params->mkey_name);
763
 
        if (params->stash_file)
764
 
            krb5_xfree(params->stash_file);
765
 
        if (params->keysalts)
766
 
            krb5_xfree(params->keysalts);
767
 
        if (params->admin_server)
768
 
             free(params->admin_server);
769
 
        if (params->admin_keytab)
770
 
             free(params->admin_keytab);
771
 
        if (params->dict_file)
772
 
             free(params->dict_file);
773
 
        if (params->acl_file)
774
 
             free(params->acl_file);
775
 
        if (params->realm)
776
 
             free(params->realm);
777
 
        if (params->admin_dbname)
778
 
             free(params->admin_dbname);
779
 
        if (params->admin_lockfile)
780
 
             free(params->admin_lockfile);
781
 
 
 
841
        free(params->dbname);
 
842
        free(params->mkey_name);
 
843
        free(params->stash_file);
 
844
        free(params->keysalts);
 
845
        free(params->admin_server);
 
846
        free(params->admin_keytab);
 
847
        free(params->dict_file);
 
848
        free(params->acl_file);
 
849
        free(params->realm);
 
850
        free(params->iprop_logfile);
782
851
    }
783
852
    return(0);
784
853
}
785
854
 
786
855
krb5_error_code
787
856
kadm5_get_admin_service_name(krb5_context ctx,
788
 
                             char *realm_in,
789
 
                             char *admin_name,
790
 
                             size_t maxlen)
 
857
                             char *realm_in,
 
858
                             char *admin_name,
 
859
                             size_t maxlen)
791
860
{
792
861
    krb5_error_code ret;
793
862
    kadm5_config_params params_in, params_out;
800
869
    params_in.realm = realm_in;
801
870
    ret = kadm5_get_config_params(ctx, 0, &params_in, &params_out);
802
871
    if (ret)
803
 
        return ret;
 
872
        return ret;
804
873
 
805
874
    if (!(params_out.mask & KADM5_CONFIG_ADMIN_SERVER)) {
806
 
        ret = KADM5_MISSING_KRB5_CONF_PARAMS;
807
 
        goto err_params;
 
875
        ret = KADM5_MISSING_KRB5_CONF_PARAMS;
 
876
        goto err_params;
808
877
    }
809
878
 
810
879
    hp = gethostbyname(params_out.admin_server);
811
880
    if (hp == NULL) {
812
 
        ret = errno;
813
 
        goto err_params;
 
881
        ret = errno;
 
882
        goto err_params;
814
883
    }
815
884
    if (strlen(hp->h_name) + sizeof("kadmin/") > maxlen) {
816
 
        ret = ENOMEM;
817
 
        goto err_params;
 
885
        ret = ENOMEM;
 
886
        goto err_params;
818
887
    }
819
 
    sprintf(admin_name, "kadmin/%s", hp->h_name);
 
888
    snprintf(admin_name, maxlen, "kadmin/%s", hp->h_name);
820
889
 
821
890
err_params:
822
891
    kadm5_free_config_params(ctx, &params_out);
825
894
 
826
895
/***********************************************************************
827
896
 * This is the old krb5_realm_read_params, which I mutated into
828
 
 * kadm5_get_config_params but which old code (kdb5_* and krb5kdc)
829
 
 * still uses.
 
897
 * kadm5_get_config_params but which old KDC code still uses.
830
898
 ***********************************************************************/
831
899
 
832
900
/*
833
 
 * krb5_read_realm_params()     - Read per-realm parameters from KDC
834
 
 *                                alternate profile.
 
901
 * krb5_read_realm_params()       - Read per-realm parameters from KDC
 
902
 *                                  alternate profile.
835
903
 */
836
904
krb5_error_code
837
905
krb5_read_realm_params(kcontext, realm, rparamp)
838
 
    krb5_context        kcontext;
839
 
    char                *realm;
840
 
    krb5_realm_params   **rparamp;
 
906
    krb5_context        kcontext;
 
907
    char                *realm;
 
908
    krb5_realm_params   **rparamp;
841
909
{
842
 
    char                *filename;
843
 
    char                *envname;
844
 
    char                *lrealm;
845
 
    krb5_pointer        aprofile = 0;
846
 
    krb5_realm_params   *rparams;
847
 
    const char          *hierarchy[4];
848
 
    char                *svalue;
849
 
    krb5_int32          ivalue;
850
 
    krb5_boolean        bvalue;
851
 
    krb5_deltat         dtvalue;
852
 
 
853
 
    char                *kdcprofile = 0;
854
 
    char                *kdcenv = 0;
855
 
 
856
 
    krb5_error_code     kret;
 
910
    char                *filename;
 
911
    char                *envname;
 
912
    char                *lrealm;
 
913
    krb5_pointer        aprofile = 0;
 
914
    krb5_realm_params   *rparams;
 
915
    const char          *hierarchy[4];
 
916
    char                *svalue;
 
917
    krb5_int32          ivalue;
 
918
    krb5_boolean        bvalue;
 
919
    krb5_deltat         dtvalue;
 
920
 
 
921
    char                *kdcprofile = 0;
 
922
    char                *kdcenv = 0;
 
923
    char                *no_refrls = 0;
 
924
    char                *host_based_srvcs = 0;
 
925
         
 
926
 
 
927
 
 
928
    krb5_error_code        kret;
857
929
 
858
930
    filename = (kdcprofile) ? kdcprofile : DEFAULT_KDC_PROFILE;
859
931
    envname = (kdcenv) ? kdcenv : KDC_PROFILE_ENV;
862
934
 
863
935
    rparams = (krb5_realm_params *) NULL;
864
936
    if (realm)
865
 
        lrealm = strdup(realm);
 
937
        lrealm = strdup(realm);
866
938
    else {
867
 
        kret = krb5_get_default_realm(kcontext, &lrealm);
868
 
        if (kret)
869
 
            goto cleanup;
 
939
        kret = krb5_get_default_realm(kcontext, &lrealm);
 
940
        if (kret)
 
941
            goto cleanup;
870
942
    }
871
943
 
872
944
    kret = krb5_aprof_init(filename, envname, &aprofile);
873
945
    if (kret)
874
 
        goto cleanup;
 
946
        goto cleanup;
875
947
    
876
948
    rparams = (krb5_realm_params *) malloc(sizeof(krb5_realm_params));
877
949
    if (rparams == 0) {
878
 
        kret = ENOMEM;
879
 
        goto cleanup;
 
950
        kret = ENOMEM;
 
951
        goto cleanup;
880
952
    }
881
953
 
882
954
    /* Initialize realm parameters */
883
955
    memset((char *) rparams, 0, sizeof(krb5_realm_params));
884
956
 
885
957
    /* Get the value for the database */
886
 
    hierarchy[0] = "realms";
 
958
    hierarchy[0] = KRB5_CONF_REALMS;
887
959
    hierarchy[1] = lrealm;
888
 
    hierarchy[2] = "database_name";
 
960
    hierarchy[2] = KRB5_CONF_DATABASE_NAME;
889
961
    hierarchy[3] = (char *) NULL;
890
962
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
891
 
        rparams->realm_dbname = svalue;
892
 
        
 
963
        rparams->realm_dbname = svalue;
 
964
        
893
965
    /* Get the value for the KDC port list */
894
 
    hierarchy[2] = "kdc_ports";
895
 
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
896
 
        rparams->realm_kdc_ports = svalue;
897
 
    hierarchy[2] = "kdc_tcp_ports";
898
 
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
899
 
        rparams->realm_kdc_tcp_ports = svalue;
 
966
    hierarchy[2] = KRB5_CONF_KDC_PORTS;
 
967
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
 
968
        rparams->realm_kdc_ports = svalue;
 
969
    hierarchy[2] = KRB5_CONF_KDC_TCP_PORTS;
 
970
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
 
971
        rparams->realm_kdc_tcp_ports = svalue;
900
972
 
901
973
    /* Get the name of the acl file */
902
 
    hierarchy[2] = "acl_file";
 
974
    hierarchy[2] = KRB5_CONF_ACL_FILE;
903
975
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
904
 
        rparams->realm_acl_file = svalue;
905
 
            
 
976
        rparams->realm_acl_file = svalue;
 
977
            
906
978
    /* Get the value for the kadmind port */
907
 
    hierarchy[2] = "kadmind_port";
 
979
    hierarchy[2] = KRB5_CONF_KADMIND_PORT;
908
980
    if (!krb5_aprof_get_int32(aprofile, hierarchy, TRUE, &ivalue)) {
909
 
        rparams->realm_kadmind_port = ivalue;
910
 
        rparams->realm_kadmind_port_valid = 1;
 
981
        rparams->realm_kadmind_port = ivalue;
 
982
        rparams->realm_kadmind_port_valid = 1;
911
983
    }
912
 
            
 
984
            
913
985
    /* Get the value for the master key name */
914
 
    hierarchy[2] = "master_key_name";
 
986
    hierarchy[2] = KRB5_CONF_MASTER_KEY_NAME;
915
987
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
916
 
        rparams->realm_mkey_name = svalue;
917
 
            
 
988
        rparams->realm_mkey_name = svalue;
 
989
            
918
990
    /* Get the value for the master key type */
919
 
    hierarchy[2] = "master_key_type";
 
991
    hierarchy[2] = KRB5_CONF_MASTER_KEY_TYPE;
920
992
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
921
 
        if (!krb5_string_to_enctype(svalue, &rparams->realm_enctype))
922
 
            rparams->realm_enctype_valid = 1;
923
 
        krb5_xfree(svalue);
 
993
        if (!krb5_string_to_enctype(svalue, &rparams->realm_enctype))
 
994
            rparams->realm_enctype_valid = 1;
 
995
        free(svalue);
924
996
    }
925
 
            
 
997
            
926
998
    /* Get the value for the stashfile */
927
 
    hierarchy[2] = "key_stash_file";
 
999
    hierarchy[2] = KRB5_CONF_KEY_STASH_FILE;
928
1000
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue))
929
 
        rparams->realm_stash_file = svalue;
930
 
            
 
1001
        rparams->realm_stash_file = svalue;
 
1002
            
931
1003
    /* Get the value for maximum ticket lifetime. */
932
 
    hierarchy[2] = "max_life";
 
1004
    hierarchy[2] = KRB5_CONF_MAX_LIFE;
933
1005
    if (!krb5_aprof_get_deltat(aprofile, hierarchy, TRUE, &dtvalue)) {
934
 
        rparams->realm_max_life = dtvalue;
935
 
        rparams->realm_max_life_valid = 1;
 
1006
        rparams->realm_max_life = dtvalue;
 
1007
        rparams->realm_max_life_valid = 1;
936
1008
    }
937
 
            
 
1009
            
938
1010
    /* Get the value for maximum renewable ticket lifetime. */
939
 
    hierarchy[2] = "max_renewable_life";
 
1011
    hierarchy[2] = KRB5_CONF_MAX_RENEWABLE_LIFE;
940
1012
    if (!krb5_aprof_get_deltat(aprofile, hierarchy, TRUE, &dtvalue)) {
941
 
        rparams->realm_max_rlife = dtvalue;
942
 
        rparams->realm_max_rlife_valid = 1;
 
1013
        rparams->realm_max_rlife = dtvalue;
 
1014
        rparams->realm_max_rlife_valid = 1;
943
1015
    }
944
 
            
 
1016
            
945
1017
    /* Get the value for the default principal expiration */
946
 
    hierarchy[2] = "default_principal_expiration";
 
1018
    hierarchy[2] = KRB5_CONF_DEFAULT_PRINCIPAL_EXPIRATION;
947
1019
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
948
 
        if (!krb5_string_to_timestamp(svalue,
949
 
                                      &rparams->realm_expiration))
950
 
            rparams->realm_expiration_valid = 1;
951
 
        krb5_xfree(svalue);
 
1020
        if (!krb5_string_to_timestamp(svalue,
 
1021
                                      &rparams->realm_expiration))
 
1022
            rparams->realm_expiration_valid = 1;
 
1023
        free(svalue);
952
1024
    }
953
1025
 
954
 
    hierarchy[2] = "reject_bad_transit";
 
1026
    hierarchy[2] = KRB5_CONF_REJECT_BAD_TRANSIT;
955
1027
    if (!krb5_aprof_get_boolean(aprofile, hierarchy, TRUE, &bvalue)) {
956
 
        rparams->realm_reject_bad_transit = bvalue;
957
 
        rparams->realm_reject_bad_transit_valid = 1;
 
1028
        rparams->realm_reject_bad_transit = bvalue;
 
1029
        rparams->realm_reject_bad_transit_valid = 1;
 
1030
    }
 
1031
 
 
1032
    hierarchy[2] = KRB5_CONF_NO_HOST_REFERRAL;
 
1033
    if (!krb5_aprof_get_string_all(aprofile, hierarchy, &no_refrls)) 
 
1034
       rparams->realm_no_host_referral = no_refrls;
 
1035
    else 
 
1036
            no_refrls = 0;
 
1037
 
 
1038
    if (!no_refrls || krb5_match_config_pattern(no_refrls, KRB5_CONF_ASTERISK) == FALSE) {
 
1039
        hierarchy[2] = KRB5_CONF_HOST_BASED_SERVICES;
 
1040
        if (!krb5_aprof_get_string_all(aprofile, hierarchy, &host_based_srvcs))
 
1041
            rparams->realm_host_based_services = host_based_srvcs;
 
1042
        else
 
1043
            host_based_srvcs = 0;
958
1044
    }
959
1045
 
960
1046
    /* Get the value for the default principal flags */
961
 
    hierarchy[2] = "default_principal_flags";
 
1047
    hierarchy[2] = KRB5_CONF_DEFAULT_PRINCIPAL_FLAGS;
962
1048
    if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) {
963
 
        char *sp, *ep, *tp;
 
1049
        char *sp, *ep, *tp;
964
1050
 
965
 
        sp = svalue;
966
 
        rparams->realm_flags = 0;
967
 
        while (sp) {
968
 
            if ((ep = strchr(sp, (int) ',')) ||
969
 
                (ep = strchr(sp, (int) ' ')) ||
970
 
                (ep = strchr(sp, (int) '\t'))) {
971
 
                /* Fill in trailing whitespace of sp */
972
 
                tp = ep - 1;
973
 
                while (isspace((int) *tp) && (tp < sp)) {
974
 
                    *tp = '\0';
975
 
                    tp--;
976
 
                }
977
 
                *ep = '\0';
978
 
                ep++;
979
 
                /* Skip over trailing whitespace of ep */
980
 
                while (isspace((int) *ep) && (*ep)) ep++;
981
 
            }
982
 
            /* Convert this flag */
983
 
            if (krb5_string_to_flags(sp,
984
 
                                     "+",
985
 
                                     "-",
986
 
                                     &rparams->realm_flags))
987
 
                break;
988
 
            sp = ep;
989
 
        }
990
 
        if (!sp)
991
 
            rparams->realm_flags_valid = 1;
992
 
        krb5_xfree(svalue);
 
1051
        sp = svalue;
 
1052
        rparams->realm_flags = 0;
 
1053
        while (sp) {
 
1054
            if ((ep = strchr(sp, (int) ',')) ||
 
1055
                (ep = strchr(sp, (int) ' ')) ||
 
1056
                (ep = strchr(sp, (int) '\t'))) {
 
1057
                /* Fill in trailing whitespace of sp */
 
1058
                tp = ep - 1;
 
1059
                while (isspace((int) *tp) && (tp < sp)) {
 
1060
                    *tp = '\0';
 
1061
                    tp--;
 
1062
                }
 
1063
                *ep = '\0';
 
1064
                ep++;
 
1065
                /* Skip over trailing whitespace of ep */
 
1066
                while (isspace((int) *ep) && (*ep)) ep++;
 
1067
            }
 
1068
            /* Convert this flag */
 
1069
            if (krb5_string_to_flags(sp,
 
1070
                                     "+",
 
1071
                                     "-",
 
1072
                                     &rparams->realm_flags))
 
1073
                break;
 
1074
            sp = ep;
 
1075
        }
 
1076
        if (!sp)
 
1077
            rparams->realm_flags_valid = 1;
 
1078
        free(svalue);
993
1079
    }
994
1080
 
995
1081
    rparams->realm_keysalts = NULL;
997
1083
 
998
1084
cleanup:
999
1085
    if (aprofile)
1000
 
        krb5_aprof_finish(aprofile);
1001
 
    if (lrealm)
1002
 
        free(lrealm);
 
1086
        krb5_aprof_finish(aprofile);
 
1087
    free(lrealm);
1003
1088
    if (kret) {
1004
 
        if (rparams)
1005
 
            krb5_free_realm_params(kcontext, rparams);
1006
 
        rparams = 0;
 
1089
        if (rparams)
 
1090
            krb5_free_realm_params(kcontext, rparams);
 
1091
        rparams = 0;
1007
1092
    }
1008
1093
    *rparamp = rparams;
1009
1094
    return(kret);
1010
1095
}
1011
1096
 
1012
1097
/*
1013
 
 * krb5_free_realm_params()     - Free data allocated by above.
 
1098
 * krb5_free_realm_params()        - Free data allocated by above.
1014
1099
 */
1015
1100
krb5_error_code
1016
1101
krb5_free_realm_params(kcontext, rparams)
1017
 
    krb5_context        kcontext;
1018
 
    krb5_realm_params   *rparams;
 
1102
    krb5_context        kcontext;
 
1103
    krb5_realm_params   *rparams;
1019
1104
{
1020
1105
    if (rparams) {
1021
 
        if (rparams->realm_profile)
1022
 
            krb5_xfree(rparams->realm_profile);
1023
 
        if (rparams->realm_dbname)
1024
 
            krb5_xfree(rparams->realm_dbname);
1025
 
        if (rparams->realm_mkey_name)
1026
 
            krb5_xfree(rparams->realm_mkey_name);
1027
 
        if (rparams->realm_stash_file)
1028
 
            krb5_xfree(rparams->realm_stash_file);
1029
 
        if (rparams->realm_keysalts)
1030
 
            krb5_xfree(rparams->realm_keysalts);
1031
 
        if (rparams->realm_kdc_ports)
1032
 
            krb5_xfree(rparams->realm_kdc_ports);
1033
 
        if (rparams->realm_kdc_tcp_ports)
1034
 
            krb5_xfree(rparams->realm_kdc_tcp_ports);
1035
 
        if (rparams->realm_acl_file)
1036
 
            krb5_xfree(rparams->realm_acl_file);
1037
 
        krb5_xfree(rparams);
 
1106
        free(rparams->realm_profile);
 
1107
        free(rparams->realm_dbname);
 
1108
        free(rparams->realm_mkey_name);
 
1109
        free(rparams->realm_stash_file);
 
1110
        free(rparams->realm_keysalts);
 
1111
        free(rparams->realm_kdc_ports);
 
1112
        free(rparams->realm_kdc_tcp_ports);
 
1113
        free(rparams->realm_acl_file);
 
1114
        free(rparams->realm_no_host_referral);
 
1115
        free(rparams->realm_host_based_services);
 
1116
        free(rparams);
1038
1117
    }
1039
1118
    return(0);
1040
1119
}
 
1120
/* 
 
1121
 * match_config_pattern - 
 
1122
 *       returns TRUE is the pattern is found in the attr's list of values.
 
1123
 *       Otherwise - FALSE.
 
1124
 *       In conf file the values are separates by commas or whitespaces.
 
1125
 */
 
1126
krb5_boolean
 
1127
krb5_match_config_pattern(const char *string, const char *pattern)
 
1128
{
 
1129
    const char *ptr;
 
1130
    char next = '\0';
 
1131
    int len = strlen(pattern);
 
1132
 
 
1133
    for (ptr = strstr(string,pattern); ptr != 0; ptr = strstr(ptr+len,pattern)) {
 
1134
         if (ptr == string || isspace(*(ptr-1)) || *(ptr-1) ==',') {
 
1135
             next = *(ptr + len);
 
1136
             if (next == '\0' || isspace(next) || next ==',') {
 
1137
                  return TRUE;
 
1138
             }
 
1139
         }
 
1140
    }
 
1141
    return FALSE;
 
1142
}
 
1143
 
 
1144
 
1041
1145