Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source3/utils/ntlm_auth.c

    r599 r745  
    2525
    2626#include "includes.h"
     27#include "popt_common.h"
    2728#include "utils/ntlm_auth.h"
    2829#include "../libcli/auth/libcli_auth.h"
    2930#include "../libcli/auth/spnego.h"
     31#include "../libcli/auth/ntlmssp.h"
    3032#include "smb_krb5.h"
    3133#include <iniparser.h>
     34#include "../lib/crypto/arcfour.h"
     35#include "libads/kerberos_proto.h"
     36#include "nsswitch/winbind_client.h"
     37#include "librpc/gen_ndr/krb5pac.h"
     38#include "../lib/util/asn1.h"
    3239
    3340#ifndef PAM_WINBIND_CONFIG_FILE
    … …  
    225232        if (opt_challenge.length)
    226233                return opt_challenge;
    227        
     234
    228235        chal = data_blob(NULL, 8);
    229236
    … …  
    244251                return False;
    245252        }
    246        
     253
    247254        fstrcpy(user, p+1);
    248255        fstrcpy(domain, domuser);
    … …  
    302309        int ctrl = 0;
    303310        dictionary *d = NULL;
    304        
     311
    305312        if (!opt_pam_winbind_conf || !*opt_pam_winbind_conf) {
    306313                opt_pam_winbind_conf = PAM_WINBIND_CONFIG_FILE;
    … …  
    308315
    309316        d = iniparser_load(CONST_DISCARD(char *, opt_pam_winbind_conf));
    310        
     317
    311318        if (!d) {
    312319                return 0;
    313320        }
    314        
     321
    315322        if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:krb5_auth"), false)) {
    316323                ctrl |= WINBIND_KRB5_AUTH;
    … …  
    318325
    319326        iniparser_freedict(d);
    320        
     327
    321328        return ctrl;
    322329}
    … …  
    440447                request.data.auth_crap.nt_resp_len = nt_response->length;
    441448        }
    442        
     449
    443450        result = winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response);
    444451        SAFE_FREE(request.extra_data.data);
    … …  
    453460                return nt_status;
    454461        }
    455        
     462
    456463        nt_status = (NT_STATUS(response.data.auth.nt_status));
    457464        if (!NT_STATUS_IS_OK(nt_status)) {
    … …  
    535542                request.data.chng_pswd_auth_crap.old_lm_hash_enc_len = old_lm_hash_enc.length;
    536543        }
    537        
     544
    538545        result = winbindd_request_response(WINBINDD_PAM_CHNG_PSWD_AUTH_CRAP, &request, &response);
    539546
    … …  
    548555                return nt_status;
    549556        }
    550        
     557
    551558        nt_status = (NT_STATUS(response.data.auth.nt_status));
    552559        if (!NT_STATUS_IS_OK(nt_status))
    … …  
    559566
    560567        winbindd_free_response(&response);
    561        
     568
    562569    return nt_status;
    563570}
    564571
    565 static NTSTATUS winbind_pw_check(struct ntlmssp_state *ntlmssp_state, DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
     572static NTSTATUS winbind_pw_check(struct ntlmssp_state *ntlmssp_state, TALLOC_CTX *mem_ctx,
     573                                 DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
    566574{
    567575        static const char zeros[16] = { 0, };
    … …  
    573581
    574582        nt_status = contact_winbind_auth_crap(ntlmssp_state->user, ntlmssp_state->domain,
    575                                               ntlmssp_state->workstation,
     583                                              ntlmssp_state->client.netbios_name,
    576584                                              &ntlmssp_state->chal,
    577585                                              &ntlmssp_state->lm_resp,
    … …  
    583591        if (NT_STATUS_IS_OK(nt_status)) {
    584592                if (memcmp(lm_key, zeros, 8) != 0) {
    585                         *lm_session_key = data_blob_talloc(ntlmssp_state, NULL, 16);
     593                        *lm_session_key = data_blob_talloc(mem_ctx, NULL, 16);
    586594                        memcpy(lm_session_key->data, lm_key, 8);
    587595                        memset(lm_session_key->data+8, '\0', 8);
    588596                }
    589                
     597
    590598                if (memcmp(user_sess_key, zeros, 16) != 0) {
    591                         *user_session_key = data_blob_talloc(ntlmssp_state, user_sess_key, 16);
    592                 }
    593                 ntlmssp_state->auth_context = talloc_strdup(ntlmssp_state,
    594                                                             unix_name);
     599                        *user_session_key = data_blob_talloc(mem_ctx, user_sess_key, 16);
     600                }
     601                ntlmssp_state->callback_private = talloc_strdup(ntlmssp_state,
     602                                                                unix_name);
    595603        } else {
    596604                DEBUG(NT_STATUS_EQUAL(nt_status, NT_STATUS_ACCESS_DENIED) ? 0 : 3,
    597605                      ("Login for user [%s]\\[%s]@[%s] failed due to [%s]\n",
    598606                       ntlmssp_state->domain, ntlmssp_state->user,
    599                        ntlmssp_state->workstation,
     607                       ntlmssp_state->client.netbios_name,
    600608                       error_string ? error_string : "unknown error (NULL)"));
    601                 ntlmssp_state->auth_context = NULL;
     609                ntlmssp_state->callback_private = NULL;
    602610        }
    603611
    … …  
    607615}
    608616
    609 static NTSTATUS local_pw_check(struct ntlmssp_state *ntlmssp_state, DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
     617static NTSTATUS local_pw_check(struct ntlmssp_state *ntlmssp_state, TALLOC_CTX *mem_ctx,
     618                               DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
    610619{
    611620        NTSTATUS nt_status;
    … …  
    613622
    614623        nt_lm_owf_gen (opt_password, nt_pw.hash, lm_pw.hash);
    615        
    616         nt_status = ntlm_password_check(ntlmssp_state,
     624
     625        nt_status = ntlm_password_check(mem_ctx,
    617626                                        true, true, 0,
    618627                                        &ntlmssp_state->chal,
    … …  
    623632                                        ntlmssp_state->domain,
    624633                                        &lm_pw, &nt_pw, user_session_key, lm_session_key);
    625        
     634
    626635        if (NT_STATUS_IS_OK(nt_status)) {
    627                 ntlmssp_state->auth_context = talloc_asprintf(ntlmssp_state,
     636                ntlmssp_state->callback_private = talloc_asprintf(ntlmssp_state,
    628637                                                              "%s%c%s", ntlmssp_state->domain,
    629638                                                              *lp_winbind_separator(),
    … …  
    631640        } else {
    632641                DEBUG(3, ("Login for user [%s]\\[%s]@[%s] failed due to [%s]\n",
    633                           ntlmssp_state->domain, ntlmssp_state->user, ntlmssp_state->workstation,
     642                          ntlmssp_state->domain, ntlmssp_state->user,
     643                          ntlmssp_state->client.netbios_name,
    634644                          nt_errstr(nt_status)));
    635                 ntlmssp_state->auth_context = NULL;
     645                ntlmssp_state->callback_private = NULL;
    636646        }
    637647        return nt_status;
    638648}
    639649
    640 static NTSTATUS ntlm_auth_start_ntlmssp_client(NTLMSSP_STATE **client_ntlmssp_state)
     650static NTSTATUS ntlm_auth_start_ntlmssp_client(struct ntlmssp_state **client_ntlmssp_state)
    641651{
    642652        NTSTATUS status;
    … …  
    647657        }
    648658
    649         status = ntlmssp_client_start(client_ntlmssp_state);
     659        status = ntlmssp_client_start(NULL,
     660                                      global_myname(),
     661                                      lp_workgroup(),
     662                                      lp_client_ntlmv2_auth(),
     663                                      client_ntlmssp_state);
    650664
    651665        if (!NT_STATUS_IS_OK(status)) {
    652666                DEBUG(1, ("Could not start NTLMSSP client: %s\n",
    653667                          nt_errstr(status)));
    654                 ntlmssp_end(client_ntlmssp_state);
     668                TALLOC_FREE(*client_ntlmssp_state);
    655669                return status;
    656670        }
    … …  
    661675                DEBUG(1, ("Could not set username: %s\n",
    662676                          nt_errstr(status)));
    663                 ntlmssp_end(client_ntlmssp_state);
     677                TALLOC_FREE(*client_ntlmssp_state);
    664678                return status;
    665679        }
    … …  
    670684                DEBUG(1, ("Could not set domain: %s\n",
    671685                          nt_errstr(status)));
    672                 ntlmssp_end(client_ntlmssp_state);
     686                TALLOC_FREE(*client_ntlmssp_state);
    673687                return status;
    674688        }
    … …  
    676690        if (opt_password) {
    677691                status = ntlmssp_set_password(*client_ntlmssp_state, opt_password);
    678        
     692
    679693                if (!NT_STATUS_IS_OK(status)) {
    680694                        DEBUG(1, ("Could not set password: %s\n",
    681695                                  nt_errstr(status)));
    682                         ntlmssp_end(client_ntlmssp_state);
     696                        TALLOC_FREE(*client_ntlmssp_state);
    683697                        return status;
    684698                }
    … …  
    688702}
    689703
    690 static NTSTATUS ntlm_auth_start_ntlmssp_server(NTLMSSP_STATE **ntlmssp_state)
    691 {
    692         NTSTATUS status = ntlmssp_server_start(ntlmssp_state);
    693        
     704static NTSTATUS ntlm_auth_start_ntlmssp_server(struct ntlmssp_state **ntlmssp_state)
     705{
     706        NTSTATUS status;
     707        const char *netbios_name;
     708        const char *netbios_domain;
     709        const char *dns_name;
     710        char *dns_domain;
     711        bool is_standalone = false;
     712
     713        if (opt_password) {
     714                netbios_name = global_myname();
     715                netbios_domain = lp_workgroup();
     716        } else {
     717                netbios_name = get_winbind_netbios_name();
     718                netbios_domain = get_winbind_domain();
     719        }
     720        /* This should be a 'netbios domain -> DNS domain' mapping */
     721        dns_domain = get_mydnsdomname(talloc_tos());
     722        if (dns_domain) {
     723                strlower_m(dns_domain);
     724        }
     725        dns_name = get_mydnsfullname();
     726
     727        status = ntlmssp_server_start(NULL,
     728                                      is_standalone,
     729                                      netbios_name,
     730                                      netbios_domain,
     731                                      dns_name,
     732                                      dns_domain,
     733                                      ntlmssp_state);
    694734        if (!NT_STATUS_IS_OK(status)) {
    695735                DEBUG(1, ("Could not start NTLMSSP server: %s\n",
    … …  
    701741        if (opt_password) {
    702742                (*ntlmssp_state)->check_password = local_pw_check;
    703                 (*ntlmssp_state)->get_domain = lp_workgroup;
    704                 (*ntlmssp_state)->get_global_myname = global_myname;
    705743        } else {
    706744                (*ntlmssp_state)->check_password = winbind_pw_check;
    707                 (*ntlmssp_state)->get_domain = get_winbind_domain;
    708                 (*ntlmssp_state)->get_global_myname = get_winbind_netbios_name;
    709745        }
    710746        return NT_STATUS_OK;
    … …  
    733769         * ntlm_ccache_auth, it will fail. So, we have to ask the trusted
    734770         * domain's child for ccache_ntlm_auth. that is to say, we have to
    735          * set WBFALG_PAM_CONTACT_TRUSTDOM in request.flags.
     771         * set WBFLAG_PAM_CONTACT_TRUSTDOM in request.flags.
    736772         */
    737773        ctrl = get_pam_winbind_config();
    … …  
    829865
    830866        if (strncmp(buf, "YR", 2) == 0) {
    831                 if (state->ntlmssp_state)
    832                         ntlmssp_end(&state->ntlmssp_state);
     867                TALLOC_FREE(state->ntlmssp_state);
    833868                state->svr_state = SERVER_INITIAL;
    834869        } else if (strncmp(buf, "KK", 2) == 0) {
    … …  
    896931                DEBUG(0, ("NTLMSSP BH: %s\n", nt_errstr(nt_status)));
    897932
    898                 ntlmssp_end(&state->ntlmssp_state);
     933                TALLOC_FREE(state->ntlmssp_state);
    899934        } else if (!NT_STATUS_IS_OK(nt_status)) {
    900935                *response = talloc_asprintf(mem_ctx, "NA %s",
    … …  
    904939                *response = talloc_asprintf(
    905940                        mem_ctx, "AF %s",
    906                         (char *)state->ntlmssp_state->auth_context);
     941                        (char *)state->ntlmssp_state->callback_private);
    907942                DEBUG(10, ("NTLMSSP OK!\n"));
    908943
    … …  
    10071042
    10081043        if (strncmp(buf, "YR", 2) == 0) {
    1009                 if (state->ntlmssp_state)
    1010                         ntlmssp_end(&state->ntlmssp_state);
     1044                TALLOC_FREE(state->ntlmssp_state);
    10111045                state->cli_state = CLIENT_INITIAL;
    10121046        } else if (strncmp(buf, "TT", 2) == 0) {
    … …  
    10991133                DEBUG(10, ("NTLMSSP OK!\n"));
    11001134                state->cli_state = CLIENT_FINISHED;
    1101                 if (state->ntlmssp_state)
    1102                         ntlmssp_end(&state->ntlmssp_state);
     1135                TALLOC_FREE(state->ntlmssp_state);
    11031136        } else {
    11041137                x_fprintf(x_stdout, "BH %s\n", nt_errstr(nt_status));
    11051138                DEBUG(0, ("NTLMSSP BH: %s\n", nt_errstr(nt_status)));
    11061139                state->cli_state = CLIENT_ERROR;
    1107                 if (state->ntlmssp_state)
    1108                         ntlmssp_end(&state->ntlmssp_state);
     1140                TALLOC_FREE(state->ntlmssp_state);
    11091141        }
    11101142
    … …  
    11171149        char *user, *pass;     
    11181150        user=buf;
    1119        
     1151
    11201152        pass=(char *)memchr(buf,' ',length);
    11211153        if (!pass) {
    … …  
    11261158        *pass='\0';
    11271159        pass++;
    1128        
     1160
    11291161        if (state->helper_mode == SQUID_2_5_BASIC) {
    11301162                rfc1738_unescape(user);
    11311163                rfc1738_unescape(pass);
    11321164        }
    1133        
     1165
    11341166        if (check_plaintext_auth(user, pass, False)) {
    11351167                x_fprintf(x_stdout, "OK\n");
    … …  
    11971229}
    11981230
    1199 static bool _spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
     1231bool spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
    12001232{
    12011233        bool ret;
    … …  
    12621294
    12631295        if (strncmp(buf, "YR", 2) == 0) {
    1264                 if (state->ntlmssp_state)
    1265                         ntlmssp_end(&state->ntlmssp_state);
     1296                TALLOC_FREE(state->ntlmssp_state);
    12661297                TALLOC_FREE(state->spnego_mech);
    12671298                TALLOC_FREE(state->spnego_mech_oid);
    … …  
    13961427                                                    "NTLMSSP challenge, but "
    13971428                                                    "already got one\n");
    1398                                 ntlmssp_end(&state->ntlmssp_state);
     1429                                TALLOC_FREE(state->ntlmssp_state);
    13991430                                return;
    14001431                        }
    … …  
    14731504                }
    14741505                if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
    1475                         ntlmssp_end(&state->ntlmssp_state);
     1506                        TALLOC_FREE(state->ntlmssp_state);
    14761507                }
    14771508#ifdef HAVE_KRB5
    … …  
    14801511                DATA_BLOB ap_rep;
    14811512                DATA_BLOB session_key;
    1482                 struct PAC_DATA *pac_data = NULL;
     1513                struct PAC_LOGON_INFO *logon_info = NULL;
    14831514                DATA_BLOB ticket;
    14841515                uint8_t tok_id[2];
    14851516
    1486                 if (!_spnego_parse_krb5_wrap(ctx, raw_in_token,
    1487                                              &ticket, tok_id)) {
     1517                if (!spnego_parse_krb5_wrap(ctx, raw_in_token,
     1518                                            &ticket, tok_id)) {
    14881519                        DEBUG(1, ("spnego_parse_krb5_wrap failed\n"));
    14891520                        x_fprintf(x_stdout, "BH spnego_parse_krb5_wrap failed\n");
    … …  
    14931524                status = ads_verify_ticket(ctx, lp_realm(), 0,
    14941525                                           &ticket,
    1495                                            &principal, &pac_data, &ap_rep,
     1526                                           &principal, &logon_info, &ap_rep,
    14961527                                           &session_key, True);
    14971528
    … …  
    15151546                        user = talloc_strdup(ctx, principal);
    15161547
    1517                         if (pac_data) {
    1518                                 struct PAC_LOGON_INFO *logon_info;
    1519                                 logon_info = get_logon_info_from_pac(
    1520                                         pac_data);
    1521                                 if (logon_info) {
    1522                                         netsamlogon_cache_store(
    1523                                                 user,
    1524                                                 &logon_info->info3);
    1525                                 }
     1548                        if (logon_info) {
     1549                                netsamlogon_cache_store(
     1550                                        user, &logon_info->info3);
    15261551                        }
    15271552
    … …  
    15871612}
    15881613
    1589 static NTLMSSP_STATE *client_ntlmssp_state = NULL;
     1614static struct ntlmssp_state *client_ntlmssp_state = NULL;
    15901615
    15911616static bool manage_client_ntlmssp_init(struct spnego_data spnego)
    … …  
    16381663                DEBUG(1, ("Expected OK or MORE_PROCESSING_REQUIRED, got: %s\n",
    16391664                          nt_errstr(status)));
    1640                 ntlmssp_end(&client_ntlmssp_state);
     1665                TALLOC_FREE(client_ntlmssp_state);
    16411666                return False;
    16421667        }
    … …  
    16711696        if (spnego.negTokenTarg.negResult == SPNEGO_REJECT) {
    16721697                x_fprintf(x_stdout, "NA\n");
    1673                 ntlmssp_end(&client_ntlmssp_state);
     1698                TALLOC_FREE(client_ntlmssp_state);
    16741699                return;
    16751700        }
    … …  
    16771702        if (spnego.negTokenTarg.negResult == SPNEGO_ACCEPT_COMPLETED) {
    16781703                x_fprintf(x_stdout, "AF\n");
    1679                 ntlmssp_end(&client_ntlmssp_state);
     1704                TALLOC_FREE(client_ntlmssp_state);
    16801705                return;
    16811706        }
    … …  
    16841709                                       spnego.negTokenTarg.responseToken,
    16851710                                       &request);
    1686                
     1711
    16871712        if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
    16881713                DEBUG(1, ("Expected MORE_PROCESSING_REQUIRED from "
    … …  
    16921717                                    "ntlmssp_client_update\n");
    16931718                data_blob_free(&request);
    1694                 ntlmssp_end(&client_ntlmssp_state);
     1719                TALLOC_FREE(client_ntlmssp_state);
    16951720                return;
    16961721        }
    … …  
    17011726        spnego.negTokenTarg.responseToken = request;
    17021727        spnego.negTokenTarg.mechListMIC = null_blob;
    1703        
     1728
    17041729        spnego_write_data(ctx, &to_server, &spnego);
    17051730        data_blob_free(&request);
    … …  
    17451770        principal[spnego.negTokenInit.mechListMIC.length] = '\0';
    17461771
    1747         retval = cli_krb5_get_ticket(principal, 0, &tkt, &session_key_krb5, 0, NULL, NULL, NULL);
    1748 
     1772        retval = cli_krb5_get_ticket(ctx, principal, 0,
     1773                                          &tkt, &session_key_krb5,
     1774                                          0, NULL, NULL, NULL);
    17491775        if (retval) {
    17501776                char *user = NULL;
    … …  
    17691795                }
    17701796
    1771                 retval = cli_krb5_get_ticket(principal, 0, &tkt, &session_key_krb5, 0, NULL, NULL, NULL);
    1772 
     1797                retval = cli_krb5_get_ticket(ctx, principal, 0,
     1798                                                  &tkt, &session_key_krb5,
     1799                                                  0, NULL, NULL, NULL);
    17731800                if (retval) {
    17741801                        DEBUG(10, ("Kinit suceeded, but getting a ticket failed: %s\n", error_message(retval)));
    … …  
    18551882
    18561883                opt_password = SMB_STRNDUP((const char *)request.data, request.length);
    1857                
     1884
    18581885                if (opt_password == NULL) {
    18591886                        DEBUG(1, ("Out of memory\n"));
    … …  
    19411968                        }
    19421969
    1943                         ntlmssp_end(&client_ntlmssp_state);
     1970                        TALLOC_FREE(client_ntlmssp_state);
    19441971                        goto out;
    19451972                }
    … …  
    19832010        static bool ntlm_server_1_user_session_key;
    19842011        static bool ntlm_server_1_lm_session_key;
    1985        
     2012
    19862013        if (strequal(buf, ".")) {
    19872014                if (!full_username && !username) {     
    … …  
    20132040                                fstring fstr_user;
    20142041                                fstring fstr_domain;
    2015                                
     2042
    20162043                                if (!parse_ntlm_auth_domain_user(full_username, fstr_user, fstr_domain)) {
    20172044                                        /* username might be 'tainted', don't print into our new-line deleimianted stream */
    … …  
    20302057                        if (ntlm_server_1_lm_session_key)
    20312058                                flags |= WBFLAG_PAM_LMKEY;
    2032                        
     2059
    20332060                        if (ntlm_server_1_user_session_key)
    20342061                                flags |= WBFLAG_PAM_USER_SESSION_KEY;
    … …  
    20992126        if (!parameter) {
    21002127                parameter = strstr_m(request, ": ");
    2101                
     2128
    21022129                if (!parameter) {
    21032130                        DEBUG(0, ("Parameter not found!\n"));
    … …  
    21052132                        return;
    21062133                }
    2107                
     2134
    21082135                parameter[0] ='\0';
    21092136                parameter++;
    … …  
    21862213                        new_nt_pswd = data_blob(NULL, 516);
    21872214                        old_nt_hash_enc = data_blob(NULL, 16);
    2188                        
     2215
    21892216                        /* Calculate the MD4 hash (NT compatible) of the
    21902217                         * password */
    … …  
    21942221                        /* E_deshash returns false for 'long'
    21952222                           passwords (> 14 DOS chars). 
    2196                            
     2223
    21972224                           Therefore, don't send a buffer
    21982225                           encrypted with the truncated hash
    … …  
    22232250                        encode_pw_buffer(new_nt_pswd.data, newpswd,
    22242251                                         STR_UNICODE);
    2225        
     2252
    22262253                        arcfour_crypt(new_nt_pswd.data, old_nt_hash, 516);
    22272254                        E_old_pw_hash(new_nt_hash, old_nt_hash,
    22282255                                      old_nt_hash_enc.data);
    22292256                }
    2230                
     2257
    22312258                if (!full_username && !username) {     
    22322259                        x_fprintf(x_stdout, "Error: No username supplied!\n");
    … …  
    22372264                } else {
    22382265                        char *error_string = NULL;
    2239                        
     2266
    22402267                        if (full_username && !username) {
    22412268                                fstring fstr_user;
    22422269                                fstring fstr_domain;
    2243                                
     2270
    22442271                                if (!parse_ntlm_auth_domain_user(full_username,
    22452272                                                                 fstr_user,
    … …  
    22592286                                        domain = smb_xstrdup(fstr_domain);
    22602287                                }
    2261                                
     2288
    22622289                        }
    22632290
    … …  
    22992326        if (!parameter) {
    23002327                parameter = strstr_m(request, ": ");
    2301                
     2328
    23022329                if (!parameter) {
    23032330                        DEBUG(0, ("Parameter not found!\n"));
    … …  
    23052332                        return;
    23062333                }
    2307                
     2334
    23082335                parameter[0] ='\0';
    23092336                parameter++;
    … …  
    25812608                { "request-nt-key", 0, POPT_ARG_NONE, &request_user_session_key, OPT_USER_SESSION_KEY, "Retrieve User (NT) session key"},
    25822609                { "use-cached-creds", 0, POPT_ARG_NONE, &use_cached_creds, OPT_USE_CACHED_CREDS, "Use cached credentials if no password is given"},
    2583                 { "diagnostics", 0, POPT_ARG_NONE, &diagnostics, OPT_DIAGNOSTICS, "Perform diagnostics on the authentictaion chain"},
     2610                { "diagnostics", 0, POPT_ARG_NONE, &diagnostics,
     2611                  OPT_DIAGNOSTICS,
     2612                  "Perform diagnostics on the authentication chain"},
    25842613                { "require-membership-of", 0, POPT_ARG_STRING, &require_membership_of, OPT_REQUIRE_MEMBERSHIP, "Require that a user be a member of this group (either name or SID) for authentication to succeed" },
    25852614                { "pam-winbind-conf", 0, POPT_ARG_STRING, &opt_pam_winbind_conf, OPT_PAM_WINBIND_CONF, "Require that request must set WBFLAG_PAM_CONTACT_TRUSTDOM when krb5 auth is required" },
    … …  
    25922621        load_case_tables();
    25932622
    2594         dbf = x_stderr;
     2623        setup_logging("ntlm_auth", DEBUG_STDERR);
    25952624
    25962625        /* Parse options */
Note: See TracChangeset for help on using the changeset viewer.