blob: cb52cbbe45ff4704790ec4ffbf0a985e3423f492 [file] [log] [blame]
Steve French50c2f752007-07-13 00:33:32 +00001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
3 * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
Steve French50c2f752007-07-13 00:33:32 +00004 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright (c) 2000 RP Internet (www.rpi.net.au).
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/kernel.h>
23#include <linux/mm.h>
24#include <linux/slab.h>
25#include "cifspdu.h"
26#include "cifsglob.h"
27#include "cifs_debug.h"
28#include "cifsproto.h"
29
30/*****************************************************************************
31 *
32 * Basic ASN.1 decoding routines (gxsnmp author Dirk Wisse)
33 *
34 *****************************************************************************/
35
36/* Class */
37#define ASN1_UNI 0 /* Universal */
38#define ASN1_APL 1 /* Application */
39#define ASN1_CTX 2 /* Context */
40#define ASN1_PRV 3 /* Private */
41
42/* Tag */
43#define ASN1_EOC 0 /* End Of Contents or N/A */
44#define ASN1_BOL 1 /* Boolean */
45#define ASN1_INT 2 /* Integer */
46#define ASN1_BTS 3 /* Bit String */
47#define ASN1_OTS 4 /* Octet String */
48#define ASN1_NUL 5 /* Null */
49#define ASN1_OJI 6 /* Object Identifier */
50#define ASN1_OJD 7 /* Object Description */
51#define ASN1_EXT 8 /* External */
52#define ASN1_SEQ 16 /* Sequence */
53#define ASN1_SET 17 /* Set */
54#define ASN1_NUMSTR 18 /* Numerical String */
55#define ASN1_PRNSTR 19 /* Printable String */
56#define ASN1_TEXSTR 20 /* Teletext String */
57#define ASN1_VIDSTR 21 /* Video String */
58#define ASN1_IA5STR 22 /* IA5 String */
59#define ASN1_UNITIM 23 /* Universal Time */
60#define ASN1_GENTIM 24 /* General Time */
61#define ASN1_GRASTR 25 /* Graphical String */
62#define ASN1_VISSTR 26 /* Visible String */
63#define ASN1_GENSTR 27 /* General String */
64
65/* Primitive / Constructed methods*/
66#define ASN1_PRI 0 /* Primitive */
67#define ASN1_CON 1 /* Constructed */
68
69/*
70 * Error codes.
71 */
72#define ASN1_ERR_NOERROR 0
73#define ASN1_ERR_DEC_EMPTY 2
74#define ASN1_ERR_DEC_EOC_MISMATCH 3
75#define ASN1_ERR_DEC_LENGTH_MISMATCH 4
76#define ASN1_ERR_DEC_BADVALUE 5
77
78#define SPNEGO_OID_LEN 7
79#define NTLMSSP_OID_LEN 10
Jeff Laytone5459372007-11-03 05:11:06 +000080#define KRB5_OID_LEN 7
81#define MSKRB5_OID_LEN 7
Linus Torvalds1da177e2005-04-16 15:20:36 -070082static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
83static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };
Jeff Laytone5459372007-11-03 05:11:06 +000084static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 };
85static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Steve French50c2f752007-07-13 00:33:32 +000087/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 * ASN.1 context.
89 */
90struct asn1_ctx {
91 int error; /* Error condition */
92 unsigned char *pointer; /* Octet just to be decoded */
93 unsigned char *begin; /* First octet */
94 unsigned char *end; /* Octet after last octet */
95};
96
97/*
98 * Octet string (not null terminated)
99 */
100struct asn1_octstr {
101 unsigned char *data;
102 unsigned int len;
103};
104
105static void
106asn1_open(struct asn1_ctx *ctx, unsigned char *buf, unsigned int len)
107{
108 ctx->begin = buf;
109 ctx->end = buf + len;
110 ctx->pointer = buf;
111 ctx->error = ASN1_ERR_NOERROR;
112}
113
114static unsigned char
115asn1_octet_decode(struct asn1_ctx *ctx, unsigned char *ch)
116{
117 if (ctx->pointer >= ctx->end) {
118 ctx->error = ASN1_ERR_DEC_EMPTY;
119 return 0;
120 }
121 *ch = *(ctx->pointer)++;
122 return 1;
123}
124
125static unsigned char
126asn1_tag_decode(struct asn1_ctx *ctx, unsigned int *tag)
127{
128 unsigned char ch;
129
130 *tag = 0;
131
132 do {
133 if (!asn1_octet_decode(ctx, &ch))
134 return 0;
135 *tag <<= 7;
136 *tag |= ch & 0x7F;
137 } while ((ch & 0x80) == 0x80);
138 return 1;
139}
140
141static unsigned char
142asn1_id_decode(struct asn1_ctx *ctx,
143 unsigned int *cls, unsigned int *con, unsigned int *tag)
144{
145 unsigned char ch;
146
147 if (!asn1_octet_decode(ctx, &ch))
148 return 0;
149
150 *cls = (ch & 0xC0) >> 6;
151 *con = (ch & 0x20) >> 5;
152 *tag = (ch & 0x1F);
153
154 if (*tag == 0x1F) {
155 if (!asn1_tag_decode(ctx, tag))
156 return 0;
157 }
158 return 1;
159}
160
161static unsigned char
162asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len)
163{
164 unsigned char ch, cnt;
165
166 if (!asn1_octet_decode(ctx, &ch))
167 return 0;
168
169 if (ch == 0x80)
170 *def = 0;
171 else {
172 *def = 1;
173
174 if (ch < 0x80)
175 *len = ch;
176 else {
177 cnt = (unsigned char) (ch & 0x7F);
178 *len = 0;
179
180 while (cnt > 0) {
181 if (!asn1_octet_decode(ctx, &ch))
182 return 0;
183 *len <<= 8;
184 *len |= ch;
185 cnt--;
186 }
187 }
188 }
189 return 1;
190}
191
192static unsigned char
193asn1_header_decode(struct asn1_ctx *ctx,
194 unsigned char **eoc,
195 unsigned int *cls, unsigned int *con, unsigned int *tag)
196{
Steve French50c2f752007-07-13 00:33:32 +0000197 unsigned int def = 0;
Steve Frenchab2f2182005-09-15 20:44:50 -0700198 unsigned int len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200 if (!asn1_id_decode(ctx, cls, con, tag))
201 return 0;
202
203 if (!asn1_length_decode(ctx, &def, &len))
204 return 0;
205
206 if (def)
207 *eoc = ctx->pointer + len;
208 else
209 *eoc = NULL;
210 return 1;
211}
212
213static unsigned char
214asn1_eoc_decode(struct asn1_ctx *ctx, unsigned char *eoc)
215{
216 unsigned char ch;
217
218 if (eoc == NULL) {
219 if (!asn1_octet_decode(ctx, &ch))
220 return 0;
221
222 if (ch != 0x00) {
223 ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
224 return 0;
225 }
226
227 if (!asn1_octet_decode(ctx, &ch))
228 return 0;
229
230 if (ch != 0x00) {
231 ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
232 return 0;
233 }
234 return 1;
235 } else {
236 if (ctx->pointer != eoc) {
237 ctx->error = ASN1_ERR_DEC_LENGTH_MISMATCH;
238 return 0;
239 }
240 return 1;
241 }
242}
243
244/* static unsigned char asn1_null_decode(struct asn1_ctx *ctx,
245 unsigned char *eoc)
246{
247 ctx->pointer = eoc;
248 return 1;
249}
250
251static unsigned char asn1_long_decode(struct asn1_ctx *ctx,
252 unsigned char *eoc, long *integer)
253{
254 unsigned char ch;
255 unsigned int len;
256
257 if (!asn1_octet_decode(ctx, &ch))
258 return 0;
259
260 *integer = (signed char) ch;
261 len = 1;
262
263 while (ctx->pointer < eoc) {
264 if (++len > sizeof(long)) {
265 ctx->error = ASN1_ERR_DEC_BADVALUE;
266 return 0;
267 }
268
269 if (!asn1_octet_decode(ctx, &ch))
270 return 0;
271
272 *integer <<= 8;
273 *integer |= ch;
274 }
275 return 1;
276}
277
278static unsigned char asn1_uint_decode(struct asn1_ctx *ctx,
279 unsigned char *eoc,
280 unsigned int *integer)
281{
282 unsigned char ch;
283 unsigned int len;
284
285 if (!asn1_octet_decode(ctx, &ch))
286 return 0;
287
288 *integer = ch;
289 if (ch == 0)
290 len = 0;
291 else
292 len = 1;
293
294 while (ctx->pointer < eoc) {
295 if (++len > sizeof(unsigned int)) {
296 ctx->error = ASN1_ERR_DEC_BADVALUE;
297 return 0;
298 }
299
300 if (!asn1_octet_decode(ctx, &ch))
301 return 0;
302
303 *integer <<= 8;
304 *integer |= ch;
305 }
306 return 1;
307}
308
309static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx,
310 unsigned char *eoc,
311 unsigned long *integer)
312{
313 unsigned char ch;
314 unsigned int len;
315
316 if (!asn1_octet_decode(ctx, &ch))
317 return 0;
318
319 *integer = ch;
320 if (ch == 0)
321 len = 0;
322 else
323 len = 1;
324
325 while (ctx->pointer < eoc) {
326 if (++len > sizeof(unsigned long)) {
327 ctx->error = ASN1_ERR_DEC_BADVALUE;
328 return 0;
329 }
330
331 if (!asn1_octet_decode(ctx, &ch))
332 return 0;
333
334 *integer <<= 8;
335 *integer |= ch;
336 }
337 return 1;
Steve French50c2f752007-07-13 00:33:32 +0000338}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340static unsigned char
341asn1_octets_decode(struct asn1_ctx *ctx,
342 unsigned char *eoc,
343 unsigned char **octets, unsigned int *len)
344{
345 unsigned char *ptr;
346
347 *len = 0;
348
349 *octets = kmalloc(eoc - ctx->pointer, GFP_ATOMIC);
350 if (*octets == NULL) {
351 return 0;
352 }
353
354 ptr = *octets;
355 while (ctx->pointer < eoc) {
356 if (!asn1_octet_decode(ctx, (unsigned char *) ptr++)) {
357 kfree(*octets);
358 *octets = NULL;
359 return 0;
360 }
361 (*len)++;
362 }
363 return 1;
364} */
365
366static unsigned char
367asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid)
368{
369 unsigned char ch;
370
371 *subid = 0;
372
373 do {
374 if (!asn1_octet_decode(ctx, &ch))
375 return 0;
376
377 *subid <<= 7;
378 *subid |= ch & 0x7F;
379 } while ((ch & 0x80) == 0x80);
380 return 1;
381}
382
Steve French50c2f752007-07-13 00:33:32 +0000383static int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384asn1_oid_decode(struct asn1_ctx *ctx,
385 unsigned char *eoc, unsigned long **oid, unsigned int *len)
386{
387 unsigned long subid;
388 unsigned int size;
389 unsigned long *optr;
390
391 size = eoc - ctx->pointer + 1;
Steve French26f57362007-08-30 22:09:15 +0000392 *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC);
393 if (*oid == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 optr = *oid;
397
398 if (!asn1_subid_decode(ctx, &subid)) {
399 kfree(*oid);
400 *oid = NULL;
401 return 0;
402 }
403
404 if (subid < 40) {
405 optr[0] = 0;
406 optr[1] = subid;
407 } else if (subid < 80) {
408 optr[0] = 1;
409 optr[1] = subid - 40;
410 } else {
411 optr[0] = 2;
412 optr[1] = subid - 80;
413 }
414
415 *len = 2;
416 optr += 2;
417
418 while (ctx->pointer < eoc) {
419 if (++(*len) > size) {
420 ctx->error = ASN1_ERR_DEC_BADVALUE;
421 kfree(*oid);
422 *oid = NULL;
423 return 0;
424 }
425
426 if (!asn1_subid_decode(ctx, optr++)) {
427 kfree(*oid);
428 *oid = NULL;
429 return 0;
430 }
431 }
432 return 1;
433}
434
435static int
436compare_oid(unsigned long *oid1, unsigned int oid1len,
437 unsigned long *oid2, unsigned int oid2len)
438{
439 unsigned int i;
440
441 if (oid1len != oid2len)
442 return 0;
443 else {
444 for (i = 0; i < oid1len; i++) {
445 if (oid1[i] != oid2[i])
446 return 0;
447 }
448 return 1;
449 }
450}
451
452 /* BB check for endian conversion issues here */
453
454int
455decode_negTokenInit(unsigned char *security_blob, int length,
456 enum securityEnum *secType)
457{
458 struct asn1_ctx ctx;
459 unsigned char *end;
460 unsigned char *sequence_end;
461 unsigned long *oid = NULL;
462 unsigned int cls, con, tag, oidlen, rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000463 bool use_ntlmssp = false;
464 bool use_kerberos = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Steve French50c2f752007-07-13 00:33:32 +0000466 *secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 /* cifs_dump_mem(" Received SecBlob ", security_blob, length); */
469
470 asn1_open(&ctx, security_blob, length);
471
472 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
Steve French26a21b92006-05-31 18:05:34 +0000473 cFYI(1, ("Error decoding negTokenInit header"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return 0;
475 } else if ((cls != ASN1_APL) || (con != ASN1_CON)
476 || (tag != ASN1_EOC)) {
477 cFYI(1, ("cls = %d con = %d tag = %d", cls, con, tag));
478 return 0;
479 } else {
480 /* remember to free obj->oid */
481 rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
482 if (rc) {
483 if ((tag == ASN1_OJI) && (cls == ASN1_PRI)) {
484 rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
485 if (rc) {
486 rc = compare_oid(oid, oidlen,
487 SPNEGO_OID,
488 SPNEGO_OID_LEN);
489 kfree(oid);
490 }
491 } else
492 rc = 0;
493 }
494
495 if (!rc) {
496 cFYI(1, ("Error decoding negTokenInit header"));
497 return 0;
498 }
499
500 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
Steve French26a21b92006-05-31 18:05:34 +0000501 cFYI(1, ("Error decoding negTokenInit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 return 0;
503 } else if ((cls != ASN1_CTX) || (con != ASN1_CON)
504 || (tag != ASN1_EOC)) {
Steve French50c2f752007-07-13 00:33:32 +0000505 cFYI(1,
506 ("cls = %d con = %d tag = %d end = %p (%d) exit 0",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 cls, con, tag, end, *end));
508 return 0;
509 }
510
511 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
Steve French26a21b92006-05-31 18:05:34 +0000512 cFYI(1, ("Error decoding negTokenInit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return 0;
514 } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
515 || (tag != ASN1_SEQ)) {
Steve French50c2f752007-07-13 00:33:32 +0000516 cFYI(1,
517 ("cls = %d con = %d tag = %d end = %p (%d) exit 1",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 cls, con, tag, end, *end));
519 return 0;
520 }
521
522 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
Steve French26a21b92006-05-31 18:05:34 +0000523 cFYI(1, ("Error decoding 2nd part of negTokenInit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return 0;
525 } else if ((cls != ASN1_CTX) || (con != ASN1_CON)
526 || (tag != ASN1_EOC)) {
527 cFYI(1,
528 ("cls = %d con = %d tag = %d end = %p (%d) exit 0",
529 cls, con, tag, end, *end));
530 return 0;
531 }
532
533 if (asn1_header_decode
534 (&ctx, &sequence_end, &cls, &con, &tag) == 0) {
Steve French26a21b92006-05-31 18:05:34 +0000535 cFYI(1, ("Error decoding 2nd part of negTokenInit"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 return 0;
537 } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
538 || (tag != ASN1_SEQ)) {
539 cFYI(1,
540 ("cls = %d con = %d tag = %d end = %p (%d) exit 1",
541 cls, con, tag, end, *end));
542 return 0;
543 }
544
545 while (!asn1_eoc_decode(&ctx, sequence_end)) {
546 rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
547 if (!rc) {
548 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000549 ("Error decoding negTokenInit hdr exit2"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 return 0;
551 }
552 if ((tag == ASN1_OJI) && (con == ASN1_PRI)) {
Jeff Laytone5459372007-11-03 05:11:06 +0000553 if (asn1_oid_decode(&ctx, end, &oid, &oidlen)) {
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000556 ("OID len = %d oid = 0x%lx 0x%lx "
557 "0x%lx 0x%lx",
558 oidlen, *oid, *(oid + 1),
559 *(oid + 2), *(oid + 3)));
Jeff Laytone5459372007-11-03 05:11:06 +0000560
561 if (compare_oid(oid, oidlen,
562 MSKRB5_OID,
563 MSKRB5_OID_LEN))
Steve French4b18f2a2008-04-29 00:06:05 +0000564 use_kerberos = true;
Jeff Laytone5459372007-11-03 05:11:06 +0000565 else if (compare_oid(oid, oidlen,
566 KRB5_OID,
567 KRB5_OID_LEN))
Steve French4b18f2a2008-04-29 00:06:05 +0000568 use_kerberos = true;
Jeff Laytone5459372007-11-03 05:11:06 +0000569 else if (compare_oid(oid, oidlen,
570 NTLMSSP_OID,
571 NTLMSSP_OID_LEN))
Steve French4b18f2a2008-04-29 00:06:05 +0000572 use_ntlmssp = true;
Jeff Laytone5459372007-11-03 05:11:06 +0000573
574 kfree(oid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
576 } else {
Steve French50c2f752007-07-13 00:33:32 +0000577 cFYI(1, ("Should be an oid what is going on?"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 }
579 }
580
581 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
582 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000583 ("Error decoding last part negTokenInit exit3"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return 0;
Steve French50c2f752007-07-13 00:33:32 +0000585 } else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
586 /* tag = 3 indicating mechListMIC */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 cFYI(1,
588 ("Exit 4 cls = %d con = %d tag = %d end = %p (%d)",
589 cls, con, tag, end, *end));
590 return 0;
591 }
592 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
593 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000594 ("Error decoding last part negTokenInit exit5"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 return 0;
596 } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
597 || (tag != ASN1_SEQ)) {
Steve French26f57362007-08-30 22:09:15 +0000598 cFYI(1, ("cls = %d con = %d tag = %d end = %p (%d)",
599 cls, con, tag, end, *end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 }
601
602 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
603 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000604 ("Error decoding last part negTokenInit exit 7"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 return 0;
606 } else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
607 cFYI(1,
608 ("Exit 8 cls = %d con = %d tag = %d end = %p (%d)",
609 cls, con, tag, end, *end));
610 return 0;
611 }
612 if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
613 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000614 ("Error decoding last part negTokenInit exit9"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 return 0;
616 } else if ((cls != ASN1_UNI) || (con != ASN1_PRI)
617 || (tag != ASN1_GENSTR)) {
618 cFYI(1,
Steve French50c2f752007-07-13 00:33:32 +0000619 ("Exit10 cls = %d con = %d tag = %d end = %p (%d)",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 cls, con, tag, end, *end));
621 return 0;
622 }
Steve French50c2f752007-07-13 00:33:32 +0000623 cFYI(1, ("Need to call asn1_octets_decode() function for %s",
624 ctx.pointer)); /* is this UTF-8 or ASCII? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 }
626
Jeff Laytone5459372007-11-03 05:11:06 +0000627 if (use_kerberos)
628 *secType = Kerberos;
629 else if (use_ntlmssp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 *secType = NTLMSSP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
632 return 1;
633}