fbb2d2287bcd012b4b2d7cda162b98742b768ae7
[amitay/samba.git] / source4 / heimdal / kuser / kinit.c
1 /*
2  * Copyright (c) 1997-2007 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include "kuser_locl.h"
35 RCSID("$Id$");
36
37 #include "krb5-v4compat.h"
38
39 #include "heimntlm.h"
40
41 int forwardable_flag    = -1;
42 int proxiable_flag      = -1;
43 int renewable_flag      = -1;
44 int renew_flag          = 0;
45 int pac_flag            = -1;
46 int validate_flag       = 0;
47 int version_flag        = 0;
48 int help_flag           = 0;
49 int addrs_flag          = -1;
50 struct getarg_strings extra_addresses;
51 int anonymous_flag      = 0;
52 char *lifetime          = NULL;
53 char *renew_life        = NULL;
54 char *server_str        = NULL;
55 char *cred_cache        = NULL;
56 char *start_str         = NULL;
57 struct getarg_strings etype_str;
58 int use_keytab          = 0;
59 char *keytab_str        = NULL;
60 int do_afslog           = -1;
61 #ifndef HEIMDAL_SMALLER
62 int get_v4_tgt          = -1;
63 int convert_524         = 0;
64 static char *krb4_cc_name;
65 #endif
66 int fcache_version;
67 char *password_file     = NULL;
68 char *pk_user_id        = NULL;
69 char *pk_x509_anchors   = NULL;
70 int pk_use_enckey       = 0;
71 static int canonicalize_flag = 0;
72 static int ok_as_delegate_flag = 0;
73 static int use_referrals_flag = 0;
74 static int windows_flag = 0;
75 static char *ntlm_domain;
76
77
78 static struct getargs args[] = {
79     /*
80      * used by MIT
81      * a: ~A
82      * V: verbose
83      * F: ~f
84      * P: ~p
85      * C: v4 cache name?
86      * 5:
87      */
88 #ifndef HEIMDAL_SMALLER
89     { "524init",        '4', arg_flag, &get_v4_tgt,
90       NP_("obtain version 4 TGT", "") },
91
92     { "524convert",     '9', arg_flag, &convert_524,
93       NP_("only convert ticket to version 4", "") },
94 #endif
95     { "afslog",         0  , arg_flag, &do_afslog,
96       NP_("obtain afs tokens", "")  },
97
98     { "cache",          'c', arg_string, &cred_cache,
99       NP_("credentials cache", ""), "cachename" },
100
101     { "forwardable",    'f', arg_flag, &forwardable_flag,
102       NP_("get forwardable tickets", "")},
103
104     { "keytab",         't', arg_string, &keytab_str,
105       NP_("keytab to use", ""), "keytabname" },
106
107     { "lifetime",       'l', arg_string, &lifetime,
108       NP_("lifetime of tickets", ""), "time"},
109
110     { "proxiable",      'p', arg_flag, &proxiable_flag,
111       NP_("get proxiable tickets", "") },
112
113     { "renew",          'R', arg_flag, &renew_flag,
114       NP_("renew TGT", "") },
115
116     { "renewable",      0,   arg_flag, &renewable_flag,
117       NP_("get renewable tickets", "") },
118
119     { "renewable-life", 'r', arg_string, &renew_life,
120       NP_("renewable lifetime of tickets", ""), "time" },
121
122     { "server",         'S', arg_string, &server_str,
123       NP_("server to get ticket for", ""), "principal" },
124
125     { "start-time",     's', arg_string, &start_str,
126       NP_("when ticket gets valid", ""), "time" },
127
128     { "use-keytab",     'k', arg_flag, &use_keytab,
129       NP_("get key from keytab", "") },
130
131     { "validate",       'v', arg_flag, &validate_flag,
132       NP_("validate TGT", "") },
133
134     { "enctypes",       'e', arg_strings, &etype_str,
135       NP_("encryption types to use", ""), "enctypes" },
136
137     { "fcache-version", 0,   arg_integer, &fcache_version,
138       NP_("file cache version to create", "") },
139
140     { "addresses",      'A',   arg_negative_flag,       &addrs_flag,
141       NP_("request a ticket with no addresses", "") },
142
143     { "extra-addresses",'a', arg_strings,       &extra_addresses,
144       NP_("include these extra addresses", ""), "addresses" },
145
146     { "anonymous",      0,   arg_flag,  &anonymous_flag,
147       NP_("request an anonymous ticket", "") },
148
149     { "request-pac",    0,   arg_flag,  &pac_flag,
150       NP_("request a Windows PAC", "") },
151
152     { "password-file",  0,   arg_string, &password_file,
153       NP_("read the password from a file", "") },
154
155     { "canonicalize",0,   arg_flag, &canonicalize_flag,
156       NP_("canonicalize client principal", "") },
157 #ifdef PKINIT
158     { "pk-user",        'C',    arg_string,     &pk_user_id,
159       NP_("principal's public/private/certificate identifier", ""), "id" },
160
161     { "x509-anchors",   'D',  arg_string, &pk_x509_anchors,
162       NP_("directory with CA certificates", ""), "directory" },
163
164     { "pk-use-enckey",  0,  arg_flag, &pk_use_enckey,
165       NP_("Use RSA encrypted reply (instead of DH)", "") },
166 #endif
167     { "ntlm-domain",    0,  arg_string, &ntlm_domain,
168       NP_("NTLM domain", ""), "domain" },
169
170     { "ok-as-delegate", 0,  arg_flag, &ok_as_delegate_flag,
171       NP_("honor ok-as-delegate on tickets", "") },
172
173     { "use-referrals",  0,  arg_flag, &use_referrals_flag,
174       NP_("only use referrals, no dns canalisation", "") },
175
176     { "windows",        0,  arg_flag, &windows_flag,
177       NP_("get windows behavior", "") },
178
179     { "version",        0,   arg_flag, &version_flag },
180     { "help",           0,   arg_flag, &help_flag }
181 };
182
183 static void
184 usage (int ret)
185 {
186     arg_printusage_i18n (args,
187                          sizeof(args)/sizeof(*args),
188                          N_("Usage: ", ""),
189                          NULL,
190                          "[principal [command]]",
191                          getarg_i18n);
192     exit (ret);
193 }
194
195 static krb5_error_code
196 get_server(krb5_context context,
197            krb5_principal client,
198            const char *server,
199            krb5_principal *princ)
200 {
201     krb5_realm *client_realm;
202     if(server)
203         return krb5_parse_name(context, server, princ);
204
205     client_realm = krb5_princ_realm (context, client);
206     return krb5_make_principal(context, princ, *client_realm,
207                                KRB5_TGS_NAME, *client_realm, NULL);
208 }
209
210 #ifndef HEIMDAL_SMALLER
211
212 static krb5_error_code
213 do_524init(krb5_context context, krb5_ccache ccache,
214            krb5_creds *creds, const char *server)
215 {
216     krb5_error_code ret;
217
218     struct credentials c;
219     krb5_creds in_creds, *real_creds;
220
221     if(creds != NULL)
222         real_creds = creds;
223     else {
224         krb5_principal client;
225         krb5_cc_get_principal(context, ccache, &client);
226         memset(&in_creds, 0, sizeof(in_creds));
227         ret = get_server(context, client, server, &in_creds.server);
228         if(ret) {
229             krb5_free_principal(context, client);
230             return ret;
231         }
232         in_creds.client = client;
233         ret = krb5_get_credentials(context, 0, ccache, &in_creds, &real_creds);
234         krb5_free_principal(context, client);
235         krb5_free_principal(context, in_creds.server);
236         if(ret)
237             return ret;
238     }
239     ret = krb524_convert_creds_kdc_ccache(context, ccache, real_creds, &c);
240     if(ret)
241         krb5_warn(context, ret, "converting creds");
242     else {
243         krb5_error_code tret = _krb5_krb_tf_setup(context, &c, NULL, 0);
244         if(tret)
245             krb5_warn(context, tret, "saving v4 creds");
246     }
247
248     if(creds == NULL)
249         krb5_free_creds(context, real_creds);
250     memset(&c, 0, sizeof(c));
251
252     return ret;
253 }
254
255 #endif
256
257 static int
258 renew_validate(krb5_context context,
259                int renew,
260                int validate,
261                krb5_ccache cache,
262                const char *server,
263                krb5_deltat life)
264 {
265     krb5_error_code ret;
266     krb5_creds in, *out = NULL;
267     krb5_kdc_flags flags;
268
269     memset(&in, 0, sizeof(in));
270
271     ret = krb5_cc_get_principal(context, cache, &in.client);
272     if(ret) {
273         krb5_warn(context, ret, "krb5_cc_get_principal");
274         return ret;
275     }
276     ret = get_server(context, in.client, server, &in.server);
277     if(ret) {
278         krb5_warn(context, ret, "get_server");
279         goto out;
280     }
281
282     if (renew) {
283         /*
284          * no need to check the error here, it's only to be
285          * friendly to the user
286          */
287         krb5_get_credentials(context, KRB5_GC_CACHED, cache, &in, &out);
288     }
289
290     flags.i = 0;
291     flags.b.renewable         = flags.b.renew = renew;
292     flags.b.validate          = validate;
293
294     if (forwardable_flag != -1)
295         flags.b.forwardable       = forwardable_flag;
296     else if (out)
297         flags.b.forwardable       = out->flags.b.forwardable;
298
299     if (proxiable_flag != -1)
300         flags.b.proxiable         = proxiable_flag;
301     else if (out)
302         flags.b.proxiable         = out->flags.b.proxiable;
303
304     if (anonymous_flag != -1)
305         flags.b.request_anonymous = anonymous_flag;
306     if(life)
307         in.times.endtime = time(NULL) + life;
308
309     if (out) {
310         krb5_free_creds (context, out);
311         out = NULL;
312     }
313
314
315     ret = krb5_get_kdc_cred(context,
316                             cache,
317                             flags,
318                             NULL,
319                             NULL,
320                             &in,
321                             &out);
322     if(ret) {
323         krb5_warn(context, ret, "krb5_get_kdc_cred");
324         goto out;
325     }
326     ret = krb5_cc_initialize(context, cache, in.client);
327     if(ret) {
328         krb5_free_creds (context, out);
329         krb5_warn(context, ret, "krb5_cc_initialize");
330         goto out;
331     }
332     ret = krb5_cc_store_cred(context, cache, out);
333
334     if(ret == 0 && server == NULL) {
335         /* only do this if it's a general renew-my-tgt request */
336 #ifndef HEIMDAL_SMALLER
337         if(get_v4_tgt)
338             do_524init(context, cache, out, NULL);
339 #endif
340         if(do_afslog && k_hasafs())
341             krb5_afslog(context, cache, NULL, NULL);
342     }
343
344     krb5_free_creds (context, out);
345     if(ret) {
346         krb5_warn(context, ret, "krb5_cc_store_cred");
347         goto out;
348     }
349 out:
350     krb5_free_cred_contents(context, &in);
351     return ret;
352 }
353
354 static krb5_error_code
355 store_ntlmkey(krb5_context context, krb5_ccache id,
356               const char *domain, struct ntlm_buf *buf)
357 {
358     krb5_error_code ret;
359     krb5_data data;
360     char *name;
361
362     asprintf(&name, "ntlm-key-%s", domain);
363     if (name == NULL) {
364         krb5_clear_error_message(context);
365         return ENOMEM;
366     }
367
368     data.length = buf->length;
369     data.data = buf->data;
370
371     ret = krb5_cc_set_config(context, id, NULL, name, &data);
372     free(name);
373     return ret;
374 }
375
376 static krb5_error_code
377 get_new_tickets(krb5_context context,
378                 krb5_principal principal,
379                 krb5_ccache ccache,
380                 krb5_deltat ticket_life,
381                 int interactive)
382 {
383     krb5_error_code ret;
384     krb5_get_init_creds_opt *opt;
385     krb5_creds cred;
386     char passwd[256];
387     krb5_deltat start_time = 0;
388     krb5_deltat renew = 0;
389     char *renewstr = NULL;
390     krb5_enctype *enctype = NULL;
391     struct ntlm_buf ntlmkey;
392     krb5_ccache tempccache;
393
394     memset(&ntlmkey, 0, sizeof(ntlmkey));
395     passwd[0] = '\0';
396
397     if (password_file) {
398         FILE *f;
399
400         if (strcasecmp("STDIN", password_file) == 0)
401             f = stdin;
402         else
403             f = fopen(password_file, "r");
404         if (f == NULL)
405             krb5_errx(context, 1, "Failed to open the password file %s",
406                       password_file);
407
408         if (fgets(passwd, sizeof(passwd), f) == NULL)
409             krb5_errx(context, 1,
410                       N_("Failed to read password from file %s", ""),
411                       password_file);
412         if (f != stdin)
413             fclose(f);
414         passwd[strcspn(passwd, "\n")] = '\0';
415     }
416
417
418     memset(&cred, 0, sizeof(cred));
419
420     ret = krb5_get_init_creds_opt_alloc (context, &opt);
421     if (ret)
422         krb5_err(context, 1, ret, "krb5_get_init_creds_opt_alloc");
423
424     krb5_get_init_creds_opt_set_default_flags(context, "kinit",
425         krb5_principal_get_realm(context, principal), opt);
426
427     if(forwardable_flag != -1)
428         krb5_get_init_creds_opt_set_forwardable (opt, forwardable_flag);
429     if(proxiable_flag != -1)
430         krb5_get_init_creds_opt_set_proxiable (opt, proxiable_flag);
431     if(anonymous_flag != -1)
432         krb5_get_init_creds_opt_set_anonymous (opt, anonymous_flag);
433     if (pac_flag != -1)
434         krb5_get_init_creds_opt_set_pac_request(context, opt,
435                                                 pac_flag ? TRUE : FALSE);
436     if (canonicalize_flag)
437         krb5_get_init_creds_opt_set_canonicalize(context, opt, TRUE);
438     if (pk_user_id) {
439         ret = krb5_get_init_creds_opt_set_pkinit(context, opt,
440                                                  principal,
441                                                  pk_user_id,
442                                                  pk_x509_anchors,
443                                                  NULL,
444                                                  NULL,
445                                                  pk_use_enckey ? 2 : 0,
446                                                  krb5_prompter_posix,
447                                                  NULL,
448                                                  passwd);
449         if (ret)
450             krb5_err(context, 1, ret, "krb5_get_init_creds_opt_set_pkinit");
451     }
452
453     if (addrs_flag != -1)
454         krb5_get_init_creds_opt_set_addressless(context, opt,
455                                                 addrs_flag ? FALSE : TRUE);
456
457     if (renew_life == NULL && renewable_flag)
458         renewstr = "1 month";
459     if (renew_life)
460         renewstr = renew_life;
461     if (renewstr) {
462         renew = parse_time (renewstr, "s");
463         if (renew < 0)
464             errx (1, "unparsable time: %s", renewstr);
465         
466         krb5_get_init_creds_opt_set_renew_life (opt, renew);
467     }
468
469     if(ticket_life != 0)
470         krb5_get_init_creds_opt_set_tkt_life (opt, ticket_life);
471
472     if(start_str) {
473         int tmp = parse_time (start_str, "s");
474         if (tmp < 0)
475             errx (1, N_("unparsable time: %s", ""), start_str);
476
477         start_time = tmp;
478     }
479
480     if(etype_str.num_strings) {
481         int i;
482
483         enctype = malloc(etype_str.num_strings * sizeof(*enctype));
484         if(enctype == NULL)
485             errx(1, "out of memory");
486         for(i = 0; i < etype_str.num_strings; i++) {
487             ret = krb5_string_to_enctype(context,
488                                          etype_str.strings[i],
489                                          &enctype[i]);
490             if(ret)
491                 errx(1, "unrecognized enctype: %s", etype_str.strings[i]);
492         }
493         krb5_get_init_creds_opt_set_etype_list(opt, enctype,
494                                                etype_str.num_strings);
495     }
496
497     if(use_keytab || keytab_str) {
498         krb5_keytab kt;
499         if(keytab_str)
500             ret = krb5_kt_resolve(context, keytab_str, &kt);
501         else
502             ret = krb5_kt_default(context, &kt);
503         if (ret)
504             krb5_err (context, 1, ret, "resolving keytab");
505         ret = krb5_get_init_creds_keytab (context,
506                                           &cred,
507                                           principal,
508                                           kt,
509                                           start_time,
510                                           server_str,
511                                           opt);
512         krb5_kt_close(context, kt);
513     } else if (pk_user_id) {
514         ret = krb5_get_init_creds_password (context,
515                                             &cred,
516                                             principal,
517                                             passwd,
518                                             krb5_prompter_posix,
519                                             NULL,
520                                             start_time,
521                                             server_str,
522                                             opt);
523     } else if (!interactive) {
524         krb5_warnx(context, "Not interactive, failed to get initial ticket");
525         krb5_get_init_creds_opt_free(context, opt);
526         return 0;
527     } else {
528
529         if (passwd[0] == '\0') {
530             char *p, *prompt;
531         
532             krb5_unparse_name (context, principal, &p);
533             asprintf (&prompt, N_("%s's Password: ", ""), p);
534             free (p);
535         
536             if (UI_UTIL_read_pw_string(passwd, sizeof(passwd)-1, prompt, 0)){
537                 memset(passwd, 0, sizeof(passwd));
538                 exit(1);
539             }
540             free (prompt);
541         }
542
543         
544         ret = krb5_get_init_creds_password (context,
545                                             &cred,
546                                             principal,
547                                             passwd,
548                                             krb5_prompter_posix,
549                                             NULL,
550                                             start_time,
551                                             server_str,
552                                             opt);
553     }
554     krb5_get_init_creds_opt_free(context, opt);
555     if (ntlm_domain && passwd[0])
556         heim_ntlm_nt_key(passwd, &ntlmkey);
557     memset(passwd, 0, sizeof(passwd));
558
559     switch(ret){
560     case 0:
561         break;
562     case KRB5_LIBOS_PWDINTR: /* don't print anything if it was just C-c:ed */
563         exit(1);
564     case KRB5KRB_AP_ERR_BAD_INTEGRITY:
565     case KRB5KRB_AP_ERR_MODIFIED:
566     case KRB5KDC_ERR_PREAUTH_FAILED:
567         krb5_errx(context, 1, N_("Password incorrect", ""));
568         break;
569     case KRB5KRB_AP_ERR_V4_REPLY:
570         krb5_errx(context, 1, N_("Looks like a Kerberos 4 reply", ""));
571         break;
572     default:
573         krb5_err(context, 1, ret, "krb5_get_init_creds");
574     }
575
576     if(ticket_life != 0) {
577         if(abs(cred.times.endtime - cred.times.starttime - ticket_life) > 30) {
578             char life[64];
579             unparse_time_approx(cred.times.endtime - cred.times.starttime,
580                                 life, sizeof(life));
581             krb5_warnx(context, N_("NOTICE: ticket lifetime is %s", ""), life);
582         }
583     }
584     if(renew_life) {
585         if(abs(cred.times.renew_till - cred.times.starttime - renew) > 30) {
586             char life[64];
587             unparse_time_approx(cred.times.renew_till - cred.times.starttime,
588                                 life, sizeof(life));
589             krb5_warnx(context, 
590                        N_("NOTICE: ticket renewable lifetime is %s", ""),
591                        life);
592         }
593     }
594
595     ret = krb5_cc_new_unique(context, krb5_cc_get_type(context, ccache),
596                              NULL, &tempccache);
597     if (ret)
598         krb5_err (context, 1, ret, "krb5_cc_new_unique");
599
600     ret = krb5_cc_initialize (context, tempccache, cred.client);
601     if (ret)
602         krb5_err (context, 1, ret, "krb5_cc_initialize");
603
604     ret = krb5_cc_store_cred (context, tempccache, &cred);
605     if (ret)
606         krb5_err (context, 1, ret, "krb5_cc_store_cred");
607
608     krb5_free_cred_contents (context, &cred);
609
610     ret = krb5_cc_move(context, tempccache, ccache);
611     if (ret)
612         krb5_err (context, 1, ret, "krb5_cc_move");
613
614     if (ntlm_domain && ntlmkey.data)
615         store_ntlmkey(context, ccache, ntlm_domain, &ntlmkey);
616
617     if (ok_as_delegate_flag || windows_flag || use_referrals_flag) {
618         unsigned char d = 0;
619         krb5_data data;
620
621         if (ok_as_delegate_flag || windows_flag)
622             d |= 1;
623         if (use_referrals_flag || windows_flag)
624             d |= 2;
625
626         data.length = 1;
627         data.data = &d;
628
629         krb5_cc_set_config(context, ccache, NULL, "realm-config", &data);
630     }
631
632
633     if (enctype)
634         free(enctype);
635
636     return 0;
637 }
638
639 static time_t
640 ticket_lifetime(krb5_context context, krb5_ccache cache,
641                 krb5_principal client, const char *server)
642 {
643     krb5_creds in_cred, *cred;
644     krb5_error_code ret;
645     time_t timeout;
646
647     memset(&in_cred, 0, sizeof(in_cred));
648
649     ret = krb5_cc_get_principal(context, cache, &in_cred.client);
650     if(ret) {
651         krb5_warn(context, ret, "krb5_cc_get_principal");
652         return 0;
653     }
654     ret = get_server(context, in_cred.client, server, &in_cred.server);
655     if(ret) {
656         krb5_free_principal(context, in_cred.client);
657         krb5_warn(context, ret, "get_server");
658         return 0;
659     }
660
661     ret = krb5_get_credentials(context, KRB5_GC_CACHED,
662                                cache, &in_cred, &cred);
663     krb5_free_principal(context, in_cred.client);
664     krb5_free_principal(context, in_cred.server);
665     if(ret) {
666         krb5_warn(context, ret, "krb5_get_credentials");
667         return 0;
668     }
669     timeout = cred->times.endtime - cred->times.starttime;
670     if (timeout < 0)
671         timeout = 0;
672     krb5_free_creds(context, cred);
673     return timeout;
674 }
675
676 struct renew_ctx {
677     krb5_context context;
678     krb5_ccache  ccache;
679     krb5_principal principal;
680     krb5_deltat ticket_life;
681 };
682
683 static time_t
684 renew_func(void *ptr)
685 {
686     struct renew_ctx *ctx = ptr;
687     krb5_error_code ret;
688     time_t expire;
689     int new_tickets = 0;
690
691     if (renewable_flag) {
692         ret = renew_validate(ctx->context, renewable_flag, validate_flag,
693                              ctx->ccache, server_str, ctx->ticket_life);
694         if (ret)
695             new_tickets = 1;
696     } else
697         new_tickets = 1;
698
699     if (new_tickets)
700         get_new_tickets(ctx->context, ctx->principal,
701                         ctx->ccache, ctx->ticket_life, 0);
702
703 #ifndef HEIMDAL_SMALLER
704     if(get_v4_tgt || convert_524)
705         do_524init(ctx->context, ctx->ccache, NULL, server_str);
706 #endif
707     if(do_afslog && k_hasafs())
708         krb5_afslog(ctx->context, ctx->ccache, NULL, NULL);
709
710     expire = ticket_lifetime(ctx->context, ctx->ccache, ctx->principal,
711                              server_str) / 2;
712     return expire + 1;
713 }
714
715 int
716 main (int argc, char **argv)
717 {
718     krb5_error_code ret;
719     krb5_context context;
720     krb5_ccache  ccache;
721     krb5_principal principal;
722     int optidx = 0;
723     krb5_deltat ticket_life = 0;
724     int parseflags = 0;
725
726     setprogname (argv[0]);
727
728     setlocale (LC_ALL, "");
729 #if defined(HEIMDAL_LOCALEDIR)
730     bindtextdomain ("heimdal_kuser", HEIMDAL_LOCALEDIR);
731     textdomain("heimdal_kuser");
732 #endif
733
734     ret = krb5_init_context (&context);
735     if (ret == KRB5_CONFIG_BADFORMAT)
736         errx (1, "krb5_init_context failed to parse configuration file");
737     else if (ret)
738         errx(1, "krb5_init_context failed: %d", ret);
739
740     if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
741         usage(1);
742
743     if (help_flag)
744         usage (0);
745
746     if(version_flag) {
747         print_version(NULL);
748         exit(0);
749     }
750
751     argc -= optidx;
752     argv += optidx;
753
754     if (canonicalize_flag)
755         parseflags |= KRB5_PRINCIPAL_PARSE_ENTERPRISE;
756
757     if (argv[0]) {
758         ret = krb5_parse_name_flags (context, argv[0], parseflags, &principal);
759         if (ret)
760             krb5_err (context, 1, ret, "krb5_parse_name");
761     } else {
762         ret = krb5_get_default_principal (context, &principal);
763         if (ret)
764             krb5_err (context, 1, ret, "krb5_get_default_principal");
765     }
766
767     if(fcache_version)
768         krb5_set_fcache_version(context, fcache_version);
769
770     if(renewable_flag == -1)
771         /* this seems somewhat pointless, but whatever */
772         krb5_appdefault_boolean(context, "kinit",
773                                 krb5_principal_get_realm(context, principal),
774                                 "renewable", FALSE, &renewable_flag);
775 #ifndef HEIMDAL_SMALLER
776     if(get_v4_tgt == -1)
777         krb5_appdefault_boolean(context, "kinit",
778                                 krb5_principal_get_realm(context, principal),
779                                 "krb4_get_tickets", FALSE, &get_v4_tgt);
780 #endif
781     if(do_afslog == -1)
782         krb5_appdefault_boolean(context, "kinit",
783                                 krb5_principal_get_realm(context, principal),
784                                 "afslog", TRUE, &do_afslog);
785
786     if(cred_cache)
787         ret = krb5_cc_resolve(context, cred_cache, &ccache);
788     else {
789         if(argc > 1) {
790             char s[1024];
791             ret = krb5_cc_gen_new(context, &krb5_fcc_ops, &ccache);
792             if(ret)
793                 krb5_err(context, 1, ret, "creating cred cache");
794             snprintf(s, sizeof(s), "%s:%s",
795                      krb5_cc_get_type(context, ccache),
796                      krb5_cc_get_name(context, ccache));
797             setenv("KRB5CCNAME", s, 1);
798 #ifndef HEIMDAL_SMALLER
799             if (get_v4_tgt) {
800                 int fd;
801                 if (asprintf(&krb4_cc_name, "%s_XXXXXX", TKT_ROOT) < 0)
802                     krb5_errx(context, 1, "out of memory");
803                 if((fd = mkstemp(krb4_cc_name)) >= 0) {
804                     close(fd);
805                     setenv("KRBTKFILE", krb4_cc_name, 1);
806                 } else {
807                     free(krb4_cc_name);
808                     krb4_cc_name = NULL;
809                 }
810             }
811 #endif
812         } else {
813             ret = krb5_cc_cache_match(context, principal, &ccache);
814             if (ret)
815                 ret = krb5_cc_default (context, &ccache);
816         }
817     }
818     if (ret)
819         krb5_err (context, 1, ret, N_("resolving credentials cache", ""));
820
821     if(argc > 1 && k_hasafs ())
822         k_setpag();
823
824     if (lifetime) {
825         int tmp = parse_time (lifetime, "s");
826         if (tmp < 0)
827             errx (1, N_("unparsable time: %s", ""), lifetime);
828
829         ticket_life = tmp;
830     }
831
832     if(addrs_flag == 0 && extra_addresses.num_strings > 0)
833         krb5_errx(context, 1,
834                   N_("specifying both extra addresses and "
835                      "no addresses makes no sense", ""));
836     {
837         int i;
838         krb5_addresses addresses;
839         memset(&addresses, 0, sizeof(addresses));
840         for(i = 0; i < extra_addresses.num_strings; i++) {
841             ret = krb5_parse_address(context, extra_addresses.strings[i],
842                                      &addresses);
843             if (ret == 0) {
844                 krb5_add_extra_addresses(context, &addresses);
845                 krb5_free_addresses(context, &addresses);
846             }
847         }
848         free_getarg_strings(&extra_addresses);
849     }
850
851     if(renew_flag || validate_flag) {
852         ret = renew_validate(context, renew_flag, validate_flag,
853                              ccache, server_str, ticket_life);
854         exit(ret != 0);
855     }
856
857 #ifndef HEIMDAL_SMALLER
858     if(!convert_524)
859 #endif
860         get_new_tickets(context, principal, ccache, ticket_life, 1);
861
862 #ifndef HEIMDAL_SMALLER
863     if(get_v4_tgt || convert_524)
864         do_524init(context, ccache, NULL, server_str);
865 #endif
866     if(do_afslog && k_hasafs())
867         krb5_afslog(context, ccache, NULL, NULL);
868     if(argc > 1) {
869         struct renew_ctx ctx;
870         time_t timeout;
871
872         timeout = ticket_lifetime(context, ccache, principal, server_str) / 2;
873
874         ctx.context = context;
875         ctx.ccache = ccache;
876         ctx.principal = principal;
877         ctx.ticket_life = ticket_life;
878
879         ret = simple_execvp_timed(argv[1], argv+1,
880                                   renew_func, &ctx, timeout);
881 #define EX_NOEXEC       126
882 #define EX_NOTFOUND     127
883         if(ret == EX_NOEXEC)
884             krb5_warnx(context, N_("permission denied: %s", ""), argv[1]);
885         else if(ret == EX_NOTFOUND)
886             krb5_warnx(context, N_("command not found: %s", ""), argv[1]);
887         
888         krb5_cc_destroy(context, ccache);
889 #ifndef HEIMDAL_SMALLER
890         _krb5_krb_dest_tkt(context, krb4_cc_name);
891 #endif
892         if(k_hasafs())
893             k_unlog();
894     } else {
895         krb5_cc_close (context, ccache);
896         ret = 0;
897     }
898     krb5_free_principal(context, principal);
899     krb5_free_context (context);
900     return ret;
901 }