← Back to branch summary

~ubuntu-branches/ubuntu/karmic/openafs/karmic-updates

« back to all changes in this revision

Viewing changes to src/kauth/test/test_interim_ktc.c

  • Committer: Bazaar Package Importer
  • Author(s): Russ Allbery
  • Date: 2008-09-22 19:07:02 UTC
  • mfrom: (12.1.14 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080922190702-59m13d7kn6gkw32d
Tags: 1.4.7.dfsg1-6
http://bugs.debian.org/493914
https://launchpad.net/bugs/267504
http://bugs.debian.org/493120
* Apply upstream patch to free /proc entries in the correct order.
  Thanks, Marc Dionne.  (Closes: #493914)
* Apply upstream deltas to support 2.6.27 kernels and to stop using
  COMMON_KERN_CFLAGS for all 2.6 kernels uniformly, which fixes
  problems on amd64 with newer kernels.  Thanks, Björn Torkelsson.
  (LP: #267504)
* Translation updates:
  - Swedish, thanks Martin Bagge.  (Closes: #493120)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kauth/test/test_interim_ktc.c
19
19
#include <afs/param.h>
20
20
 
21
21
RCSID
22
 
    ("$Header: /cvs/openafs/src/kauth/test/test_interim_ktc.c,v 1.7 2003/07/15 23:15:18 shadow Exp $");
 
22
    ("$Header: /cvs/openafs/src/kauth/test/test_interim_ktc.c,v 1.7.2.1 2007/04/10 18:43:43 shadow Exp $");
23
23
 
24
24
#include <afs/stds.h>
25
25
#include <afs/com_err.h>
117
117
 
118
118
    code = ktc_SetToken(server, token, client, 0);
119
119
    if (code) {
120
 
        com_err(whoami, code, "using SetToken to set vice id");
 
120
        afs_com_err(whoami, code, "using SetToken to set vice id");
121
121
        return 1;
122
122
    }
123
123
    sprintf(name_buf, "Unix UID %d", getuid());
128
128
        fprintf(stderr, "GetToken returned bad client: '");
129
129
        PrintPrincipal(stderr, &nclient);
130
130
        fprintf(stderr, "'\n");
131
 
        com_err(whoami, code, "should have gotten '%s'", name_buf);
 
131
        afs_com_err(whoami, code, "should have gotten '%s'", name_buf);
132
132
        return 1;
133
133
    }
134
134
    lifetime =
135
135
        (unsigned long)ntoken.endTime - (unsigned long)ntoken.startTime;
136
136
    if ((lifetime & 1) == 1) {
137
 
        com_err(whoami, code, "GetToken returned even lifetime (%d)",
 
137
        afs_com_err(whoami, code, "GetToken returned even lifetime (%d)",
138
138
                lifetime);
139
139
        return 1;
140
140
    }
157
157
    viceId = atoi((client->name) + 7);
158
158
    code = ktc_SetToken(server, token, client, 0);
159
159
    if (code) {
160
 
        com_err(whoami, code, "using SetToken to set vice id to %d", viceId);
 
160
        afs_com_err(whoami, code, "using SetToken to set vice id to %d", viceId);
161
161
        return 1;
162
162
    }
163
163
    code = ktc_GetToken(server, &ntoken, sizeof(ntoken), &nclient);
169
169
        fprintf(stderr, "' should have gotten '");
170
170
        PrintPrincipal(stderr, client);
171
171
        fprintf(stderr, "'\n");
172
 
        com_err(whoami, code, "didn't preserve AFS ID");
 
172
        afs_com_err(whoami, code, "didn't preserve AFS ID");
173
173
        return 1;
174
174
    }
175
175
    lifetime =
176
176
        (unsigned long)ntoken.endTime - (unsigned long)ntoken.startTime;
177
177
    if ((lifetime & 1) == 0) {
178
 
        com_err(whoami, code, "GetToken returned even lifetime (%d)",
 
178
        afs_com_err(whoami, code, "GetToken returned even lifetime (%d)",
179
179
                lifetime);
180
180
        return 1;
181
181
    }
265
265
    buffer.out_size = 0;
266
266
    code = pioctl(0, _VICEIOCTL(3), &buffer, 1);
267
267
    if (code) {
268
 
        com_err(whoami, errno, "setting old-style token");
 
268
        afs_com_err(whoami, errno, "setting old-style token");
269
269
        return 1;
270
270
    }
271
271
 
322
322
            if (errno == EDOM)
323
323
                break;          /* done with the list */
324
324
            else {
325
 
                com_err(whoami, code, "getting cell list");
 
325
                afs_com_err(whoami, code, "getting cell list");
326
326
                exit(1);
327
327
            }
328
328
        }
494
494
    blob.out = space;
495
495
    code = pioctl(pathname, VIOCGETAL, &blob, 1);
496
496
    if (code) {
497
 
        com_err(whoami, errno, "getting acl for %s", pathname);
 
497
        afs_com_err(whoami, errno, "getting acl for %s", pathname);
498
498
        return 1;
499
499
    }
500
500
    if (verbose > 1)
538
538
    blob.in_size = 1 + strlen(blob.in);
539
539
    code = pioctl(pathname, VIOCSETAL, &blob, 1);
540
540
    if (code) {
541
 
        com_err(whoami, errno, "setting acl on %s to %s", pathname, blob.in);
 
541
        afs_com_err(whoami, errno, "setting acl on %s to %s", pathname, blob.in);
542
542
        return 1;
543
543
    }
544
544
    if (verbose > 1) {
566
566
    token.endTime = 0;
567
567
    code = ktc_SetToken(&server, &token, &client, 0);
568
568
    if (code) {
569
 
        com_err(whoami, code, "freeing cell");
 
569
        afs_com_err(whoami, code, "freeing cell");
570
570
        exit(1);
571
571
    }
572
572
}
596
596
    strcpy(server.cell, cell);
597
597
    code = ktc_GetToken(&server, &token, sizeof(token), &client);
598
598
    if (code) {
599
 
        com_err(whoami, code, "so couldn't get %s's afs token in %s", name,
 
599
        afs_com_err(whoami, code, "so couldn't get %s's afs token in %s", name,
600
600
                cell);
601
601
        return code;
602
602
    }
648
648
    strcpy(server.cell, ka_LocalCell());
649
649
    code = ktc_GetToken(&server, &token, sizeof(token), &client);
650
650
    if (code) {
651
 
        com_err(whoami, code, "so couldn't get afs token");
 
651
        afs_com_err(whoami, code, "so couldn't get afs token");
652
652
        return code;
653
653
    }
654
654
 
655
655
    code = mkdir(tdpath, 0777);
656
656
    if (code && (errno != EEXIST)) {
657
 
        com_err(whoami, errno, "making test dir %s", tdpath);
 
657
        afs_com_err(whoami, errno, "making test dir %s", tdpath);
658
658
        return code;
659
659
    }
660
660
    fd = open(tfpath, O_WRONLY + O_CREAT + O_TRUNC, 0777);
661
661
    if (fd == -1) {
662
 
        com_err(whoami, errno, "making test file %s", tfpath);
 
662
        afs_com_err(whoami, errno, "making test file %s", tfpath);
663
663
        goto failed;
664
664
    }
665
665
    code = close(fd);
666
666
    if (code) {
667
 
        com_err(whoami, errno, "failed to close %s after create", tfpath);
 
667
        afs_com_err(whoami, errno, "failed to close %s after create", tfpath);
668
668
        goto failed;
669
669
    }
670
670
 
678
678
        goto failed;
679
679
    code = ktc_GetToken(&server, &ntoken, sizeof(ntoken), &nclient);
680
680
    if (code) {
681
 
        com_err(whoami, code, "getting new local afs token");
 
681
        afs_com_err(whoami, code, "getting new local afs token");
682
682
        goto failed;
683
683
    }
684
684
 
705
705
 
706
706
    code = open(tfpath, O_RDONLY, 0);   /* check for read access */
707
707
    if (!((code == -1) && ((errno == ENOENT) || (errno == EACCES)))) {
708
 
        com_err(whoami, errno, "didn't fail to open %s for read", tfpath);
 
708
        afs_com_err(whoami, errno, "didn't fail to open %s for read", tfpath);
709
709
        goto failed;
710
710
    }
711
711
 
712
712
    /* as tester we should have read but not write */
713
713
    code = ktc_SetToken(&server, &ntoken, &nclient, 0);
714
714
    if (code) {
715
 
        com_err(whoami, code, "restoring new local afs token");
 
715
        afs_com_err(whoami, code, "restoring new local afs token");
716
716
        goto failed;
717
717
    }
718
718
    code = open(tfpath, O_RDWR + O_TRUNC, 0);
719
719
    if ((code != -1) || (errno != EACCES)) {
720
 
        com_err(whoami, errno, "didn't fail to open %s for write", tfpath);
 
720
        afs_com_err(whoami, errno, "didn't fail to open %s for write", tfpath);
721
721
        goto failed;
722
722
    }
723
723
    fd = open(tfpath, O_RDONLY, 0);
724
724
    if (fd == -1) {
725
 
        com_err(whoami, errno, "failed to open %s for read", tfpath);
 
725
        afs_com_err(whoami, errno, "failed to open %s for read", tfpath);
726
726
        goto failed;
727
727
    }
728
728
    code = close(fd);
729
729
    if (code) {
730
 
        com_err(whoami, errno, "failed to close %s after open", tfpath);
 
730
        afs_com_err(whoami, errno, "failed to close %s after open", tfpath);
731
731
        goto failed;
732
732
    }
733
733
 
735
735
    /* go back to original privileges */
736
736
    code = ktc_SetToken(&server, &token, &client, 0);
737
737
    if (code) {
738
 
        com_err(whoami, code, "so couldn't set afs token in new pag");
 
738
        afs_com_err(whoami, code, "so couldn't set afs token in new pag");
739
739
        exit(1);
740
740
    }
741
741
    if (unlink(tfpath) || rmdir(tdpath)) {
742
 
        com_err(whoami, errno, "removing test dir %s", tdpath);
 
742
        afs_com_err(whoami, errno, "removing test dir %s", tdpath);
743
743
        return 1;
744
744
    }
745
745
    return exitCode;
765
765
 
766
766
    srandom(1);
767
767
 
768
 
    /* Initialize com_err error code hacking */
 
768
    /* Initialize afs_com_err error code hacking */
769
769
    initialize_U_error_table();
770
770
    initialize_KA_error_table();
771
771
    initialize_RXK_error_table();
824
824
    /* expand requested cell name */
825
825
    code = ka_CellConfig(AFSCONF_CLIENTNAME);
826
826
    if (code)
827
 
        com_err(whoami, code, "calling cell config");
 
827
        afs_com_err(whoami, code, "calling cell config");
828
828
    code = ka_ExpandCell(cell, cell, 0);
829
829
    if (code) {
830
 
        com_err(whoami, code, "expanding cell %s", cell);
 
830
        afs_com_err(whoami, code, "expanding cell %s", cell);
831
831
        exit(1);
832
832
    }
833
833
 
837
837
    if (printToken) {
838
838
        code = ktc_GetToken(&server, &token, sizeof(token), &client);
839
839
        if (code) {
840
 
            com_err(whoami, code, "so couldn't get afs token");
 
840
            afs_com_err(whoami, code, "so couldn't get afs token");
841
841
            exit(1);
842
842
        }
843
843
        PrintAuthentication(stdout, &server, &token, &client);
867
867
    memcpy(&ntoken, &token, sizeof(ntoken));
868
868
    code = ktc_SetToken(&server, &ntoken, &client, 0);
869
869
    if (code != KTC_NOCELL) {
870
 
        com_err(whoami, code,
 
870
        afs_com_err(whoami, code,
871
871
                "should have gotten bad pioctl error calling SetToken with bogus cell name");
872
872
        goto failed;
873
873
    }
876
876
    ntoken.ticketLen = 0;
877
877
    code = ktc_SetToken(&server, &ntoken, &client, 0);
878
878
    if ((code != KTC_TOOBIG) && (code != KTC_PIOCTLFAIL)) {
879
 
        com_err(whoami, code,
 
879
        afs_com_err(whoami, code,
880
880
                "should have gotten error calling SetToken with zero ticket length");
881
881
        goto failed;
882
882
    }
884
884
    ntoken.endTime = 0;
885
885
    code = ktc_SetToken(&server, &ntoken, &client, 0);
886
886
    if (code) {
887
 
        com_err(whoami, code, "calling SetToken with zero expiration time");
 
887
        afs_com_err(whoami, code, "calling SetToken with zero expiration time");
888
888
        goto failed;
889
889
    }
890
890
    strcpy(nclient.name, "foo");
892
892
    strcpy(nclient.cell, "foo.bar.baz");
893
893
    code = ktc_SetToken(&server, &ntoken, &nclient, 0);
894
894
    if (code) {
895
 
        com_err(whoami, code, "calling SetToken with bogus client cell");
 
895
        afs_com_err(whoami, code, "calling SetToken with bogus client cell");
896
896
        goto failed;
897
897
    }
898
898
    memcpy(&ntoken, &token, sizeof(ntoken));