← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/tests/gss-threads/gss-server.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/tests/gss-threads/gss-server.c
20
20
 * PERFORMANCE OF THIS SOFTWARE.
21
21
 */
22
22
/*
23
 
 * Copyright (C) 2004 by the Massachusetts Institute of Technology.
 
23
 * Copyright (C) 2004,2008 by the Massachusetts Institute of Technology.
24
24
 * All rights reserved.
25
25
 *
26
26
 * Export of this software from the United States of America may
55
55
#include <pthread.h>
56
56
#include <signal.h>
57
57
#endif
 
58
#include "autoconf.h"
58
59
#ifdef HAVE_UNISTD_H
59
60
#include <unistd.h>
60
61
#endif
82
83
     exit(1);
83
84
}
84
85
 
85
 
FILE *log;
 
86
FILE *logfile;
86
87
 
87
88
int verbose = 0;
88
89
 
182
183
     }
183
184
 
184
185
     if (! (token_flags & TOKEN_NOOP)) {
185
 
       if (log)
186
 
         fprintf(log, "Expected NOOP token, got %d token instead\n",
 
186
       if (logfile)
 
187
         fprintf(logfile, "Expected NOOP token, got %d token instead\n",
187
188
                 token_flags);
188
189
       return -1;
189
190
     }
195
196
         if (recv_token(s, &token_flags, &recv_tok) < 0)
196
197
           return -1;
197
198
 
198
 
         if (verbose && log) {
199
 
           fprintf(log, "Received token (size=%d): \n", (int) recv_tok.length);
 
199
         if (verbose && logfile) {
 
200
           fprintf(logfile, "Received token (size=%d): \n", (int) recv_tok.length);
200
201
           print_token(&recv_tok);
201
202
         }
202
203
 
219
220
         }
220
221
 
221
222
         if (send_tok.length != 0) {
222
 
           if (verbose && log) {
223
 
             fprintf(log,
 
223
           if (verbose && logfile) {
 
224
             fprintf(logfile,
224
225
                     "Sending accept_sec_context token (size=%d):\n",
225
226
                     (int) send_tok.length);
226
227
             print_token(&send_tok);
227
228
           }
228
229
           if (send_token(s, TOKEN_CONTEXT, &send_tok) < 0) {
229
 
             if (log)
230
 
               fprintf(log, "failure sending token\n");
 
230
             if (logfile)
 
231
               fprintf(logfile, "failure sending token\n");
231
232
             return -1;
232
233
           }
233
234
 
242
243
              return -1;
243
244
         }
244
245
 
245
 
         if (verbose && log) {
 
246
         if (verbose && logfile) {
246
247
           if (maj_stat == GSS_S_CONTINUE_NEEDED)
247
 
             fprintf(log, "continue needed...\n");
 
248
             fprintf(logfile, "continue needed...\n");
248
249
           else
249
 
             fprintf(log, "\n");
250
 
           fflush(log);
 
250
             fprintf(logfile, "\n");
 
251
           fflush(logfile);
251
252
         }
252
253
       } while (maj_stat == GSS_S_CONTINUE_NEEDED);
253
254
 
254
255
       /* display the flags */
255
256
       display_ctx_flags(*ret_flags);
256
257
 
257
 
       if (verbose && log) {
 
258
       if (verbose && logfile) {
258
259
         maj_stat = gss_oid_to_str(&min_stat, doid, &oid_name);
259
260
         if (maj_stat != GSS_S_COMPLETE) {
260
261
           display_status("converting oid->string", maj_stat, min_stat);
261
262
           return -1;
262
263
         }
263
 
         fprintf(log, "Accepted connection using mechanism OID %.*s.\n",
 
264
         fprintf(logfile, "Accepted connection using mechanism OID %.*s.\n",
264
265
                 (int) oid_name.length, (char *) oid_name.value);
265
266
         (void) gss_release_buffer(&min_stat, &oid_name);
266
267
       }
279
280
     else {
280
281
       client_name->length = *ret_flags = 0;
281
282
 
282
 
       if (log)
283
 
         fprintf(log, "Accepted unauthenticated connection.\n");
 
283
       if (logfile)
 
284
         fprintf(logfile, "Accepted unauthenticated connection.\n");
284
285
     }
285
286
 
286
287
     return 0;
361
362
                return 1;
362
363
        }
363
364
        gettimeofday(&tm2, (struct timezone *)0);
364
 
        if (verbose && log)
365
 
                fprintf(log, "Exported context: %d bytes, %7.4f seconds\n",
 
365
        if (verbose && logfile)
 
366
                fprintf(logfile, "Exported context: %d bytes, %7.4f seconds\n",
366
367
                        (int) context_token.length, 
367
368
                        timeval_subtract(&tm2, &tm1));
368
369
        copied_token.length = context_token.length;
369
370
        copied_token.value = malloc(context_token.length);
370
371
        if (copied_token.value == 0) {
371
 
          if (log)
372
 
            fprintf(log, "Couldn't allocate memory to copy context token.\n");
 
372
          if (logfile)
 
373
            fprintf(logfile, "Couldn't allocate memory to copy context token.\n");
373
374
          return 1;
374
375
        }
375
376
        memcpy(copied_token.value, context_token.value, copied_token.length);
380
381
        }
381
382
        free(copied_token.value);
382
383
        gettimeofday(&tm1, (struct timezone *)0);
383
 
        if (verbose && log)
384
 
                fprintf(log, "Importing context: %7.4f seconds\n",
 
384
        if (verbose && logfile)
 
385
                fprintf(logfile, "Importing context: %7.4f seconds\n",
385
386
                        timeval_subtract(&tm1, &tm2));
386
387
        (void) gss_release_buffer(&min_stat, &context_token);
387
388
        return 0;
451
452
            return(-1);
452
453
 
453
454
        if (token_flags & TOKEN_NOOP) {
454
 
            if (log)
455
 
                fprintf(log, "NOOP token\n");
 
455
            if (logfile)
 
456
                fprintf(logfile, "NOOP token\n");
456
457
            if(xmit_buf.value) {
457
458
                free(xmit_buf.value);
458
459
                xmit_buf.value = 0;
460
461
            break;
461
462
        }
462
463
 
463
 
        if (verbose && log) {
464
 
            fprintf(log, "Message token (flags=%d):\n", token_flags);
 
464
        if (verbose && logfile) {
 
465
            fprintf(logfile, "Message token (flags=%d):\n", token_flags);
465
466
            print_token(&xmit_buf);
466
467
        }
467
468
 
468
469
        if ((context == GSS_C_NO_CONTEXT) &&
469
470
             (    token_flags & (TOKEN_WRAPPED|TOKEN_ENCRYPTED|TOKEN_SEND_MIC))) {
470
 
            if (log)
471
 
                fprintf(log,
 
471
            if (logfile)
 
472
                fprintf(logfile,
472
473
                         "Unauthenticated client requested authenticated services!\n");
473
474
            if(xmit_buf.value) {
474
475
                free (xmit_buf.value);
500
501
            msg_buf = xmit_buf;
501
502
        }
502
503
 
503
 
        if (log) {
504
 
            fprintf(log, "Received message: ");
 
504
        if (logfile) {
 
505
            fprintf(logfile, "Received message: ");
505
506
            cp = msg_buf.value;
506
507
            if ((isprint((int) cp[0]) || isspace((int) cp[0])) &&
507
508
                 (isprint((int) cp[1]) || isspace((int) cp[1]))) {
508
 
                fprintf(log, "\"%.*s\"\n", (int) msg_buf.length, 
 
509
                fprintf(logfile, "\"%.*s\"\n", (int) msg_buf.length, 
509
510
                         (char *) msg_buf.value);
510
511
                 } else {
511
 
                     fprintf(log, "\n");
 
512
                     fprintf(logfile, "\n");
512
513
                     print_token(&msg_buf);
513
514
                 }
514
515
        }
555
556
        }
556
557
    }
557
558
 
558
 
    if (log)
559
 
        fflush(log);
 
559
    if (logfile)
 
560
        fflush(logfile);
560
561
 
561
562
    return(0);
562
563
}
636
637
    if (counter == max_threads) {
637
638
        err = pthread_cond_wait(&counter_cond, &counter_mutex);
638
639
        if (err) {
 
640
            pthread_mutex_unlock(&counter_mutex);
639
641
            perror("pthread_cond_wait");
640
642
            return 0;
641
643
        }
699
701
     int export = 0;
700
702
 
701
703
     signal(SIGPIPE, SIG_IGN);
702
 
     log = stdout;
 
704
     logfile = stdout;
703
705
     display_file = stdout;
704
706
     argc--; argv++;
705
707
     while (argc) {
731
733
                 more efficient because it doesn't actually write data
732
734
                 to /dev/null. */
733
735
              if (! strcmp(*argv, "/dev/null")) {
734
 
                log = display_file = NULL;
 
736
                logfile = display_file = NULL;
735
737
              }
736
738
              else {
737
 
                log = fopen(*argv, "a");
738
 
                display_file = log;
739
 
                if (!log) {
 
739
                logfile = fopen(*argv, "a");
 
740
                display_file = logfile;
 
741
                if (!logfile) {
740
742
                  perror(*argv);
741
743
                  exit(1);
742
744
                }