← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/kadmin/testing/util/tcl_kadm5.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/kadmin/testing/util/tcl_kadm5.c
142
142
    return TCL_OK;
143
143
}
144
144
 
145
 
static int get_server_handle(Tcl_Interp *interp, char *name, void **handle) 
 
145
static int get_server_handle(Tcl_Interp *interp, const char *name,
 
146
                             void **handle) 
146
147
{
147
148
    Tcl_HashEntry *entry;
148
149
 
163
164
    return TCL_OK;
164
165
}
165
166
 
166
 
static int remove_server_handle(Tcl_Interp *interp, char *name) 
 
167
static int remove_server_handle(Tcl_Interp *interp, const char *name)
167
168
{
168
169
    Tcl_HashEntry *entry;
169
170
 
179
180
 
180
181
#define GET_HANDLE(num_args, ignored) \
181
182
    void *server_handle; \
182
 
    char *whoami = argv[0]; \
 
183
    const char *whoami = argv[0]; \
183
184
    argv++, argc--; \
184
185
    if (argc != num_args + 1) { \
185
186
        Tcl_AppendResult(interp, whoami, ": ", arg_error, 0); \
245
246
 
246
247
 
247
248
          
248
 
static int parse_str(Tcl_Interp *interp, char *in_str, char **out_str)
 
249
static int parse_str(Tcl_Interp *interp, const char *in_str, char **out_str)
249
250
{
250
251
     if (! in_str) {
251
252
          *out_str = 0;
254
255
          *out_str = 0;
255
256
     }
256
257
     else {
257
 
          *out_str = in_str;
 
258
          *out_str = (char *) in_str;
258
259
     }
259
260
     return TCL_OK;
260
261
}
417
418
     case ENOENT: code_string = "ENOENT"; break;
418
419
 
419
420
     default:
420
 
         fprintf(stderr, "**** CODE %d (%s) ***\n", code,
 
421
         fprintf(stderr, "**** CODE %ld (%s) ***\n", (long) code,
421
422
                 error_message (code));
422
423
         code_string = "UNKNOWN";
423
424
         break;
508
509
          sprintf(buf, "%d", tl_data->tl_data_length);
509
510
          Tcl_DStringAppendElement(str, buf);
510
511
          Tcl_DStringAppend(str, " ", 1);
511
 
          Tcl_DStringAppend(str, tl_data->tl_data_contents,
 
512
          Tcl_DStringAppend(str, (char *) tl_data->tl_data_contents,
512
513
                            tl_data->tl_data_length);
513
514
          Tcl_DStringEndSublist(str);
514
515
     }
541
542
 
542
543
 
543
544
static int parse_flags(Tcl_Interp *interp, Tcl_HashTable *table,
544
 
                       struct flagval *array, int size, char *str,
 
545
                       struct flagval *array, int size, const char *str,
545
546
                       krb5_flags *flags)
546
547
{
547
548
     int tmp, argc, i, retcode = TCL_OK;
548
 
     char **argv;
 
549
     const char **argv;
549
550
     Tcl_HashEntry *entry;
550
551
 
551
552
     if (Tcl_GetInt(interp, str, &tmp) == TCL_OK) {
573
574
          *flags |= *(krb5_flags *) Tcl_GetHashValue(entry);
574
575
     }
575
576
  
576
 
     Tcl_Free(argv);
 
577
     Tcl_Free((char *) argv);
577
578
     return(retcode);
578
579
}
579
580
 
590
591
                          sizeof(struct flagval), flags);
591
592
}
592
593
 
593
 
static int parse_krb5_flags(Tcl_Interp *interp, char *str, krb5_flags *flags)
 
594
static int parse_krb5_flags(Tcl_Interp *interp, const char *str,
 
595
                            krb5_flags *flags)
594
596
{
595
597
     krb5_flags tmp;
596
598
     static Tcl_HashTable *table = 0;
614
616
}
615
617
 
616
618
 
617
 
static int parse_aux_attributes(Tcl_Interp *interp, char *str, long *flags)
 
619
static int parse_aux_attributes(Tcl_Interp *interp, const char *str,
 
620
                                long *flags)
618
621
{
619
622
     krb5_flags tmp;
620
623
     static Tcl_HashTable *table = 0;
631
634
     return TCL_OK;
632
635
}
633
636
 
634
 
static int parse_principal_mask(Tcl_Interp *interp, char *str, krb5_int32 *flags)
 
637
static int parse_principal_mask(Tcl_Interp *interp, const char *str,
 
638
                                krb5_int32 *flags)
635
639
{
636
640
     krb5_flags tmp;
637
641
     static Tcl_HashTable *table = 0;
648
652
     return TCL_OK;
649
653
}
650
654
 
651
 
static int parse_policy_mask(Tcl_Interp *interp, char *str, krb5_int32 *flags)
 
655
static int parse_policy_mask(Tcl_Interp *interp, const char *str,
 
656
                             krb5_int32 *flags)
652
657
{
653
658
     krb5_flags tmp;
654
659
     static Tcl_HashTable *table = 0;
787
792
     return str;
788
793
}
789
794
 
790
 
static int parse_keysalts(Tcl_Interp *interp, char *list,
 
795
static int parse_keysalts(Tcl_Interp *interp, const char *list,
791
796
                          krb5_key_salt_tuple **keysalts,
792
797
                          int num_keysalts)
793
798
{
794
 
     char **argv, **argv1 = NULL;
 
799
     const char **argv, **argv1 = NULL;
795
800
     int i, tmp, argc, argc1, retcode;
796
801
 
797
802
     *keysalts = NULL;
835
840
          }
836
841
          (*keysalts)[i].ks_salttype = tmp;
837
842
 
838
 
          Tcl_Free(argv1);
 
843
          Tcl_Free((char *) argv1);
839
844
          argv1 = NULL;
840
845
     }
841
846
 
842
847
finished:
843
848
     if (argv1) {
844
 
          Tcl_Free(argv1);
 
849
         Tcl_Free((char *) argv1);
845
850
     }
846
 
     Tcl_Free(argv);
 
851
     Tcl_Free((char *) argv);
847
852
     return retcode;
848
853
}
849
854
 
850
 
static int parse_key_data(Tcl_Interp *interp, char *list,
 
855
static int parse_key_data(Tcl_Interp *interp, const char *list,
851
856
                          krb5_key_data **key_data,
852
857
                          int n_key_data)
853
858
{
854
 
     char **argv;
 
859
     const char **argv;
855
860
     int argc, retcode;
856
861
 
857
862
     *key_data = NULL;
882
887
     }
883
888
 
884
889
finished:
885
 
     Tcl_Free(argv);
 
890
     Tcl_Free((char *) argv);
886
891
     return retcode;
887
892
}
888
893
 
889
 
static int parse_tl_data(Tcl_Interp *interp, char *list,
 
894
static int parse_tl_data(Tcl_Interp *interp, const char *list,
890
895
                         krb5_tl_data **tlp,
891
896
                         int n_tl_data)
892
897
{
893
898
     krb5_tl_data *tl, *tl2;
894
 
     char **argv, **argv1 = NULL;
 
899
     const char **argv, **argv1 = NULL;
895
900
     int i, tmp, argc, argc1, retcode;
896
901
 
897
902
     *tlp = NULL;
951
956
          tl->tl_data_length = tmp;
952
957
          if (tl->tl_data_length != strlen(argv1[2])) {
953
958
               sprintf(interp->result, "specified length %d does not "
954
 
                       "match length %d of string \"%s\"", tmp,
955
 
                       strlen(argv1[2]), argv1[2]);
 
959
                       "match length %lu of string \"%s\"", tmp,
 
960
                       (unsigned long) strlen(argv1[2]), argv1[2]);
956
961
               retcode = TCL_ERROR;
957
962
               goto finished;
958
963
          }
959
 
          tl->tl_data_contents = (krb5_octet *) malloc(tmp+1);
960
 
          strcpy((char *) tl->tl_data_contents, argv1[2]);
 
964
          tl->tl_data_contents = (krb5_octet *) strdup(argv1[2]);
961
965
 
962
 
          Tcl_Free(argv1);
 
966
          Tcl_Free((char *) argv1);
963
967
          argv1 = NULL;
964
968
          tl = tl->tl_data_next;
965
969
     }
972
976
 
973
977
finished:
974
978
     if (argv1) {
975
 
          Tcl_Free(argv1);
 
979
         Tcl_Free((char *) argv1);
976
980
     }
977
 
     Tcl_Free(argv);
 
981
     Tcl_Free((char *) argv);
978
982
     return retcode;
979
983
}
980
984
 
982
986
                               kadm5_config_params *params)
983
987
{
984
988
     static Tcl_HashTable *table = 0;
985
 
     char **argv = NULL;
 
989
     const char **argv = NULL;
986
990
     int tmp, argc, retcode;
987
991
 
988
992
     memset(params, 0, sizeof(kadm5_config_params));
1032
1036
          retcode = TCL_ERROR;
1033
1037
          goto finished;
1034
1038
     }
1035
 
     if ((retcode = parse_str(interp, argv[5], &params->admin_dbname)) != TCL_OK) {
1036
 
          Tcl_AppendElement(interp, "while parsing admin_dbname name");
1037
 
          retcode = TCL_ERROR;
1038
 
          goto finished;
1039
 
     }
1040
 
     if ((retcode = parse_str(interp, argv[6], &params->admin_lockfile)) != TCL_OK) {
1041
 
          Tcl_AppendElement(interp, "while parsing admin_lockfile name");
1042
 
          retcode = TCL_ERROR;
1043
 
          goto finished;
1044
 
     }
 
1039
     /* Ignore argv[5], which used to set the admin_dbname field.  */
 
1040
     /* Ignore argv[6], which used to set the admin_lockfile field.  */
1045
1041
     if ((retcode = parse_str(interp, argv[7], &params->admin_keytab)) != TCL_OK) {
1046
1042
          Tcl_AppendElement(interp, "while parsing admin_keytab name");
1047
1043
          retcode = TCL_ERROR;
1130
1126
static int parse_principal_ent(Tcl_Interp *interp, char *list,
1131
1127
                               kadm5_principal_ent_t *out_princ)
1132
1128
{
1133
 
     kadm5_principal_ent_t princ;
 
1129
     kadm5_principal_ent_t princ = 0;
1134
1130
     krb5_error_code krb5_ret;
1135
1131
     int tcl_ret;
1136
1132
     int argc;
1137
 
     char **argv;
 
1133
     const char **argv;
1138
1134
     int tmp;
1139
1135
     int retcode = TCL_OK;
1140
1136
 
1326
1322
     }
1327
1323
 
1328
1324
finished:
1329
 
     Tcl_Free(argv);
 
1325
     Tcl_Free((char *) argv);
1330
1326
     *out_princ = princ;
1331
1327
     return retcode;
1332
1328
}
1383
1379
static int parse_policy_ent(Tcl_Interp *interp, char *list,
1384
1380
                            kadm5_policy_ent_t *out_policy)
1385
1381
{
1386
 
     kadm5_policy_ent_t policy;
 
1382
     kadm5_policy_ent_t policy = 0;
1387
1383
     int tcl_ret;
1388
1384
     int argc;
1389
 
     char **argv;
 
1385
     const char **argv;
1390
1386
     int tmp;
1391
1387
     int retcode = TCL_OK;
1392
1388
 
1475
1471
     policy->policy_refcnt = tmp;
1476
1472
 
1477
1473
finished:
1478
 
     Tcl_Free(argv);
 
1474
     Tcl_Free((char *) argv);
1479
1475
     *out_policy = policy;
1480
1476
     return retcode;
1481
1477
}
1558
1554
enum init_type { INIT_NONE, INIT_PASS, INIT_CREDS };
1559
1555
     
1560
1556
static int _tcl_kadm5_init_any(enum init_type init_type, ClientData clientData,
1561
 
                        Tcl_Interp *interp, int argc, char *argv[])
 
1557
                        Tcl_Interp *interp, int argc, const char *argv[])
1562
1558
{
1563
1559
     kadm5_ret_t ret;
1564
1560
     char *client_name, *pass, *service_name;
1565
1561
     int tcl_ret;
1566
1562
     krb5_ui_4 struct_version, api_version;
1567
 
     char *handle_var;
 
1563
     const char *handle_var;
1568
1564
     void *server_handle;
1569
1565
     char *handle_name, *params_str;
1570
 
     char *whoami = argv[0];
 
1566
     const char *whoami = argv[0];
1571
1567
     kadm5_config_params params;
1572
1568
 
1573
1569
     argv++, argc--;
1643
1639
}
1644
1640
 
1645
1641
static int tcl_kadm5_init(ClientData clientData, Tcl_Interp *interp,
1646
 
                          int argc, char *argv[])
 
1642
                          int argc, const char *argv[])
1647
1643
{
1648
1644
     return _tcl_kadm5_init_any(INIT_PASS, clientData, interp, argc, argv);
1649
1645
}
1650
1646
 
1651
1647
static int tcl_kadm5_init_with_creds(ClientData clientData, Tcl_Interp *interp,
1652
 
                                     int argc, char *argv[])
 
1648
                                     int argc, const char *argv[])
1653
1649
{
1654
1650
     return _tcl_kadm5_init_any(INIT_CREDS, clientData, interp, argc, argv);
1655
1651
}
1656
1652
 
1657
1653
static int tcl_kadm5_destroy(ClientData clientData, Tcl_Interp *interp,
1658
 
                             int argc, char *argv[])
 
1654
                             int argc, const char *argv[])
1659
1655
{
1660
1656
     kadm5_ret_t ret;
1661
1657
     int tcl_ret;
1679
1675
 
1680
1676
static int tcl_kadm5_create_principal(ClientData clientData, 
1681
1677
                                      Tcl_Interp *interp,
1682
 
                                      int argc, char *argv[])
 
1678
                                      int argc, const char *argv[])
1683
1679
{
1684
1680
     int tcl_ret;
1685
1681
     kadm5_ret_t ret;
1749
1745
 
1750
1746
static int tcl_kadm5_delete_principal(ClientData clientData, 
1751
1747
                                      Tcl_Interp *interp,
1752
 
                                      int argc, char *argv[])
 
1748
                                      int argc, const char *argv[])
1753
1749
{
1754
1750
     krb5_principal princ;
1755
1751
     krb5_error_code krb5_ret;
1787
1783
 
1788
1784
static int tcl_kadm5_modify_principal(ClientData clientData, 
1789
1785
                                      Tcl_Interp *interp,
1790
 
                                      int argc, char *argv[])
 
1786
                                      int argc, const char *argv[])
1791
1787
{
1792
1788
     char *princ_string;
1793
1789
     kadm5_principal_ent_t princ = 0;
1834
1830
 
1835
1831
static int tcl_kadm5_rename_principal(ClientData clientData, 
1836
1832
                                      Tcl_Interp *interp,
1837
 
                                      int argc, char *argv[])
 
1833
                                      int argc, const char *argv[])
1838
1834
{
1839
1835
     krb5_principal source, target;
1840
1836
     krb5_error_code krb5_ret;
1875
1871
          
1876
1872
static int tcl_kadm5_chpass_principal(ClientData clientData, 
1877
1873
                                      Tcl_Interp *interp,
1878
 
                                      int argc, char *argv[])
 
1874
                                      int argc, const char *argv[])
1879
1875
{
1880
1876
     krb5_principal princ;
1881
1877
     char *pw;
1931
1927
 
1932
1928
static int tcl_kadm5_chpass_principal_util(ClientData clientData,
1933
1929
                                           Tcl_Interp *interp,
1934
 
                                           int argc, char *argv[])
 
1930
                                           int argc, const char *argv[])
1935
1931
{
1936
1932
     krb5_principal princ;
1937
1933
     char *new_pw;
2016
2012
 
2017
2013
static int tcl_kadm5_randkey_principal(ClientData clientData, 
2018
2014
                                       Tcl_Interp *interp,
2019
 
                                       int argc, char *argv[])
 
2015
                                       int argc, const char *argv[])
2020
2016
{
2021
2017
     krb5_principal princ;
2022
2018
     krb5_keyblock *keyblocks;
2089
2085
 
2090
2086
 
2091
2087
static int tcl_kadm5_get_principal(ClientData clientData, Tcl_Interp *interp,
2092
 
                                   int argc, char *argv[])
 
2088
                                   int argc, const const char *argv[])
2093
2089
{
2094
2090
     krb5_principal princ;
2095
2091
     kadm5_principal_ent_rec ent;
2163
2159
}
2164
2160
     
2165
2161
static int tcl_kadm5_create_policy(ClientData clientData, Tcl_Interp *interp,
2166
 
                                   int argc, char *argv[])
 
2162
                                   int argc, const char *argv[])
2167
2163
{
2168
2164
     int tcl_ret;
2169
2165
     kadm5_ret_t ret;
2211
2207
 
2212
2208
 
2213
2209
static int tcl_kadm5_delete_policy(ClientData clientData, Tcl_Interp *interp,
2214
 
                                   int argc, char *argv[])
 
2210
                                   int argc, const char *argv[])
2215
2211
{
2216
2212
     kadm5_ret_t ret;
2217
2213
     char *policy;
2238
2234
 
2239
2235
 
2240
2236
static int tcl_kadm5_modify_policy(ClientData clientData, Tcl_Interp *interp,
2241
 
                                   int argc, char *argv[])
 
2237
                                   int argc, const char *argv[])
2242
2238
{
2243
2239
     char *policy_string;
2244
2240
     kadm5_policy_ent_t policy = 0;
2284
2280
 
2285
2281
 
2286
2282
static int tcl_kadm5_get_policy(ClientData clientData, Tcl_Interp *interp,
2287
 
                                int argc, char *argv[])
 
2283
                                int argc, const char *argv[])
2288
2284
{
2289
2285
     kadm5_policy_ent_rec ent;
2290
2286
     Tcl_DString *ent_dstring = 0;
2343
2339
     
2344
2340
static int tcl_kadm5_free_principal_ent(ClientData clientData,
2345
2341
                                        Tcl_Interp *interp,
2346
 
                                        int argc, char *argv[])
 
2342
                                        int argc, const char *argv[])
2347
2343
{
2348
2344
     char *ent_name;
2349
2345
     kadm5_principal_ent_t ent;
2399
2395
                    
2400
2396
static int tcl_kadm5_free_policy_ent(ClientData clientData,
2401
2397
                                     Tcl_Interp *interp,
2402
 
                                     int argc, char *argv[])
 
2398
                                     int argc, const char *argv[])
2403
2399
{
2404
2400
     char *ent_name;
2405
2401
     kadm5_policy_ent_t ent;
2453
2449
          
2454
2450
                    
2455
2451
static int tcl_kadm5_get_privs(ClientData clientData, Tcl_Interp *interp,
2456
 
                               int argc, char *argv[])
 
2452
                               int argc, const char *argv[])
2457
2453
{
2458
 
     char *set_ret;
 
2454
     const char *set_ret;
2459
2455
     kadm5_ret_t ret;
2460
2456
     char *priv_var;
2461
2457
     long privs;