Ignore:
Timestamp:
Nov 24, 2016, 1:14:11 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • vendor/current/nsswitch/pam_winbind.c

    r860 r988  
    1212
    1313#include "pam_winbind.h"
    14 #define CONST_DISCARD(type,ptr) ((type)(void *)ptr)
    15 
     14
     15enum pam_winbind_request_type
     16{
     17        PAM_WINBIND_AUTHENTICATE,
     18        PAM_WINBIND_SETCRED,
     19        PAM_WINBIND_ACCT_MGMT,
     20        PAM_WINBIND_OPEN_SESSION,
     21        PAM_WINBIND_CLOSE_SESSION,
     22        PAM_WINBIND_CHAUTHTOK,
     23        PAM_WINBIND_CLEANUP
     24};
    1625
    1726static int wbc_error_to_pam_error(wbcErr status)
     
    141150        do { \
    142151                _pam_log_debug(ctx, LOG_DEBUG, "[pamh: %p] LEAVE: " \
    143                                function " returning %d (%s)", ctx->pamh, retval, \
     152                               function " returning %d (%s)", ctx ? ctx->pamh : NULL, retval, \
    144153                               _pam_error_code_str(retval)); \
    145154                _pam_log_state(ctx); \
     
    164173#endif
    165174
    166 
    167 /*
    168  * Work around the pam API that has functions with void ** as parameters
    169  * These lead to strict aliasing warnings with gcc.
    170  */
    171 static int _pam_get_item(const pam_handle_t *pamh,
    172                          int item_type,
    173                          const void *_item)
    174 {
    175         const void **item = (const void **)_item;
    176         return pam_get_item(pamh, item_type, item);
    177 }
    178 static int _pam_get_data(const pam_handle_t *pamh,
    179                          const char *module_data_name,
    180                          const void *_data)
    181 {
    182         const void **data = (const void **)_data;
    183         return pam_get_data(pamh, module_data_name, data);
    184 }
    185175
    186176/* some syslogging */
     
    203193        const char *service;
    204194
    205         _pam_get_item(pamh, PAM_SERVICE, &service);
     195        pam_get_item(pamh, PAM_SERVICE, (const void **) &service);
    206196
    207197        format2 = (char *)malloc(strlen(MODULE_NAME)+strlen(format)+strlen(service)+5);
     
    281271        va_list args;
    282272
    283         if (!_pam_log_is_debug_enabled(r->ctrl)) {
     273        if (!r || !_pam_log_is_debug_enabled(r->ctrl)) {
    284274                return;
    285275        }
     
    350340        _pam_log_state_datum(ctx, item_type, #item_type, \
    351341                             _LOG_PASSWORD_AS_STRING)
     342/*
     343 * wrapper to preserve old behaviour of iniparser which ignored
     344 * key values that had no value assigned like
     345 *    key =
     346 * for a key like above newer iniparser will return a zero-length
     347 * string, previously iniparser would return NULL
     348 *
     349 * JRA: For compatibility, tiniparser behaves like iniparser.
     350 */
     351static const char *tiniparser_getstring_nonempty(struct tiniparser_dictionary *d,
     352                        const char *key,
     353                        const char *def)
     354{
     355        const char *ret = tiniparser_getstring(d, key, def);
     356        if (ret && strlen(ret) == 0) {
     357                ret = NULL;
     358        }
     359        return ret;
     360}
    352361
    353362static void _pam_log_state(struct pwb_context *ctx)
    354363{
    355         if (!_pam_log_is_debug_state_enabled(ctx->ctrl)) {
     364        if (!ctx || !_pam_log_is_debug_state_enabled(ctx->ctrl)) {
    356365                return;
    357366        }
     
    389398                      int argc,
    390399                      const char **argv,
    391                       dictionary **result_d)
     400                      enum pam_winbind_request_type type,
     401                      struct tiniparser_dictionary **result_d)
    392402{
    393403        int ctrl = 0;
     
    395405        int i;
    396406        const char **v;
    397         dictionary *d = NULL;
     407        struct tiniparser_dictionary *d = NULL;
    398408
    399409        if (flags & PAM_SILENT) {
     
    413423        }
    414424
    415         d = iniparser_load(CONST_DISCARD(char *, config_file));
     425        d = tiniparser_load(config_file);
    416426        if (d == NULL) {
    417427                goto config_from_pam;
    418428        }
    419429
    420         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:debug"), false)) {
     430        if (tiniparser_getboolean(d, "global:debug", false)) {
    421431                ctrl |= WINBIND_DEBUG_ARG;
    422432        }
    423433
    424         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:debug_state"), false)) {
     434        if (tiniparser_getboolean(d, "global:debug_state", false)) {
    425435                ctrl |= WINBIND_DEBUG_STATE;
    426436        }
    427437
    428         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:cached_login"), false)) {
     438        if (tiniparser_getboolean(d, "global:cached_login", false)) {
    429439                ctrl |= WINBIND_CACHED_LOGIN;
    430440        }
    431441
    432         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:krb5_auth"), false)) {
     442        if (tiniparser_getboolean(d, "global:krb5_auth", false)) {
    433443                ctrl |= WINBIND_KRB5_AUTH;
    434444        }
    435445
    436         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:silent"), false)) {
     446        if (tiniparser_getboolean(d, "global:silent", false)) {
    437447                ctrl |= WINBIND_SILENT;
    438448        }
    439449
    440         if (iniparser_getstring(d, CONST_DISCARD(char *, "global:krb5_ccache_type"), NULL) != NULL) {
     450        if (tiniparser_getstring_nonempty(d, "global:krb5_ccache_type", NULL) != NULL) {
    441451                ctrl |= WINBIND_KRB5_CCACHE_TYPE;
    442452        }
    443453
    444         if ((iniparser_getstring(d, CONST_DISCARD(char *, "global:require-membership-of"), NULL)
     454        if ((tiniparser_getstring_nonempty(d, "global:require-membership-of", NULL)
    445455             != NULL) ||
    446             (iniparser_getstring(d, CONST_DISCARD(char *, "global:require_membership_of"), NULL)
     456            (tiniparser_getstring_nonempty(d, "global:require_membership_of", NULL)
    447457             != NULL)) {
    448458                ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
    449459        }
    450460
    451         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:try_first_pass"), false)) {
     461        if (tiniparser_getboolean(d, "global:try_first_pass", false)) {
    452462                ctrl |= WINBIND_TRY_FIRST_PASS_ARG;
    453463        }
    454464
    455         if (iniparser_getint(d, CONST_DISCARD(char *, "global:warn_pwd_expire"), 0)) {
     465        if (tiniparser_getint(d, "global:warn_pwd_expire", 0)) {
    456466                ctrl |= WINBIND_WARN_PWD_EXPIRE;
    457467        }
    458468
    459         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:mkhomedir"), false)) {
     469        if (tiniparser_getboolean(d, "global:mkhomedir", false)) {
    460470                ctrl |= WINBIND_MKHOMEDIR;
    461471        }
     
    480490                else if (!strcasecmp(*v, "unknown_ok"))
    481491                        ctrl |= WINBIND_UNKNOWN_OK_ARG;
    482                 else if (!strncasecmp(*v, "require_membership_of",
    483                                       strlen("require_membership_of")))
     492                else if ((type == PAM_WINBIND_AUTHENTICATE
     493                          || type == PAM_WINBIND_SETCRED)
     494                         && !strncasecmp(*v, "require_membership_of",
     495                                         strlen("require_membership_of")))
    484496                        ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
    485                 else if (!strncasecmp(*v, "require-membership-of",
    486                                       strlen("require-membership-of")))
     497                else if ((type == PAM_WINBIND_AUTHENTICATE
     498                          || type == PAM_WINBIND_SETCRED)
     499                         && !strncasecmp(*v, "require-membership-of",
     500                                         strlen("require-membership-of")))
    487501                        ctrl |= WINBIND_REQUIRED_MEMBERSHIP;
    488502                else if (!strcasecmp(*v, "krb5_auth"))
     
    495509                else if (!strcasecmp(*v, "mkhomedir"))
    496510                        ctrl |= WINBIND_MKHOMEDIR;
    497                 else {
     511                else if (!strncasecmp(*v, "warn_pwd_expire",
     512                        strlen("warn_pwd_expire")))
     513                        ctrl |= WINBIND_WARN_PWD_EXPIRE;
     514                else if (type != PAM_WINBIND_CLEANUP) {
    498515                        __pam_log(pamh, ctrl, LOG_ERR,
    499516                                 "pam_parse: unknown option: %s", *v);
     
    507524        } else {
    508525                if (d) {
    509                         iniparser_freedict(d);
     526                        tiniparser_freedict(d);
    510527                }
    511528        }
     
    521538
    522539        if (ctx->dict) {
    523                 iniparser_freedict(ctx->dict);
     540                tiniparser_freedict(ctx->dict);
    524541        }
    525542
     
    531548                                     int argc,
    532549                                     const char **argv,
     550                                     enum pam_winbind_request_type type,
    533551                                     struct pwb_context **ctx_p)
    534552{
     
    539557#endif
    540558
    541         r = TALLOC_ZERO_P(NULL, struct pwb_context);
     559        r = talloc_zero(NULL, struct pwb_context);
    542560        if (!r) {
    543561                return PAM_BUF_ERR;
     
    550568        r->argc = argc;
    551569        r->argv = argv;
    552         r->ctrl = _pam_parse(pamh, flags, argc, argv, &r->dict);
     570        r->ctrl = _pam_parse(pamh, flags, argc, argv, type, &r->dict);
    553571        if (r->ctrl == -1) {
    554572                TALLOC_FREE(r);
     
    565583                                      int error_status)
    566584{
    567         int ctrl = _pam_parse(pamh, 0, 0, NULL, NULL);
     585        int ctrl = _pam_parse(pamh, 0, 0, NULL, PAM_WINBIND_CLEANUP, NULL);
    568586        if (_pam_log_is_debug_state_enabled(ctrl)) {
    569587                __pam_log_debug(pamh, ctrl, LOG_DEBUG,
     
    646664        struct pam_conv *conv;
    647665
    648         retval = _pam_get_item(pamh, PAM_CONV, &conv);
     666        retval = pam_get_item(pamh, PAM_CONV, (const void **) &conv);
    649667        if (retval == PAM_SUCCESS) {
    650668                retval = conv->conv(nargs,
    651                                     (const struct pam_message **)message,
     669                                    discard_const_p(const struct pam_message *, message),
    652670                                    response, conv->appdata_ptr);
    653671        }
     
    813831        struct pam_message msg, *pmsg;
    814832        struct pam_response *resp = NULL;
    815         const char *prompt;
    816833        int ret;
    817834        bool retval = false;
    818         prompt = _("Do you want to change your password now?");
    819835        pmsg = &msg;
    820836        msg.msg_style = PAM_RADIO_TYPE;
    821         msg.msg = prompt;
     837        msg.msg = _("Do you want to change your password now?");
    822838        ret = converse(ctx->pamh, 1, &pmsg, &resp);
    823839        if (resp == NULL) {
     
    10501066                               int dest_buffer_size)
    10511067{
    1052         int dest_length = strlen(dest);
    1053         int src_length = strlen(src);
    1054 
    1055         if (dest_length + src_length + 1 > dest_buffer_size) {
    1056                 return false;
    1057         }
    1058 
    1059         memcpy(dest + dest_length, src, src_length + 1);
    1060         return true;
     1068        size_t len;
     1069        len = strlcat(dest, src, dest_buffer_size);
     1070        return (len < dest_buffer_size);
    10611071}
    10621072
     
    12211231                                struct wbcLogonUserInfo *info)
    12221232{
    1223         char var[PATH_MAX];
     1233        char *var = NULL;
    12241234        int ret;
    12251235        uint32_t i;
     
    12481258                       "request returned KRB5CCNAME: %s", krb5ccname);
    12491259
    1250         if (snprintf(var, sizeof(var), "KRB5CCNAME=%s", krb5ccname) == -1) {
     1260        if (asprintf(&var, "KRB5CCNAME=%s", krb5ccname) == -1) {
    12511261                return;
    12521262        }
    12531263
    12541264        ret = pam_putenv(ctx->pamh, var);
    1255         if (ret) {
     1265        if (ret != PAM_SUCCESS) {
    12561266                _pam_log(ctx, LOG_ERR,
    12571267                         "failed to set KRB5CCNAME to %s: %s",
    12581268                         var, pam_strerror(ctx->pamh, ret));
    12591269        }
     1270        free(var);
    12601271}
    12611272
     
    13181329        ret = pam_set_data(ctx->pamh, data_name, talloc_strdup(NULL, value),
    13191330                           _pam_winbind_cleanup_func);
    1320         if (ret) {
     1331        if (ret != PAM_SUCCESS) {
    13211332                _pam_log_debug(ctx, LOG_DEBUG,
    13221333                               "Could not set data %s: %s\n",
     
    16461657
    16471658                ret = _pam_create_homedir(ctx, create_dir, mode);
    1648                 if (ret) {
     1659                if (ret != PAM_SUCCESS) {
    16491660                        return ret;
    16501661                }
     
    17711782                                             "krb5_cc_type",
    17721783                                             0,
    1773                                              (uint8_t *)cctype,
     1784                                             discard_const_p(uint8_t, cctype),
    17741785                                             strlen(cctype)+1);
    17751786                if (!WBC_ERROR_IS_OK(wbc_status)) {
     
    19521963
    19531964        params.account_name             = user;
    1954         params.level                    = WBC_AUTH_USER_LEVEL_PLAIN;
     1965        params.level                    = WBC_CHANGE_PASSWORD_LEVEL_PLAIN;
    19551966        params.old_password.plaintext   = oldpass;
    19561967        params.new_password.plaintext   = newpass;
     
    19912002
    19922003                /* FIXME: avoid to send multiple PAM messages after another */
    1993                 switch (reject_reason) {
     2004                switch ((int)reject_reason) {
    19942005                        case -1:
    19952006                                break;
     
    21292140        if (on(WINBIND_TRY_FIRST_PASS_ARG, ctrl) ||
    21302141            on(WINBIND_USE_FIRST_PASS_ARG, ctrl)) {
    2131                 retval = _pam_get_item(ctx->pamh, authtok_flag, &item);
     2142                retval = pam_get_item(ctx->pamh,
     2143                                      authtok_flag,
     2144                                      (const void **) &item);
    21322145                if (retval != PAM_SUCCESS) {
    21332146                        /* very strange. */
     
    22372250        _pam_delete(token);     /* clean it up */
    22382251        if (retval != PAM_SUCCESS ||
    2239             (retval = _pam_get_item(ctx->pamh, authtok_flag, &item)) != PAM_SUCCESS) {
     2252            (retval = pam_get_item(ctx->pamh, authtok_flag, (const void **) &item)) != PAM_SUCCESS) {
    22402253
    22412254                _pam_log(ctx, LOG_CRIT, "error manipulating password");
     
    22872300                }
    22882301
    2289                 parm_opt = iniparser_getstring(ctx->dict, key, NULL);
     2302                parm_opt = tiniparser_getstring_nonempty(ctx->dict, key, NULL);
    22902303                TALLOC_FREE(key);
    22912304
     
    23352348                }
    23362349
    2337                 parm_opt = iniparser_getint(ctx->dict, key, -1);
     2350                parm_opt = tiniparser_getint(ctx->dict, key, -1);
    23382351                TALLOC_FREE(key);
    23392352
     
    23572370        ret = get_conf_item_string(ctx, "require_membership_of",
    23582371                                   WINBIND_REQUIRED_MEMBERSHIP);
    2359         if (ret) {
     2372        if (ret != NULL) {
    23602373                return ret;
    23612374        }
     
    23702383                                  WINBIND_WARN_PWD_EXPIRE);
    23712384        /* no or broken setting */
    2372         if (ret <= 0) {
     2385        if (ret < 0) {
    23732386                return DEFAULT_DAYS_TO_WARN_BEFORE_PWD_EXPIRES;
    23742387        }
     
    24092422 *
    24102423 * @param ctx PAM winbind context.
    2411  * @param upn  USer UPN to be trabslated.
     2424 * @param upn  User UPN to be translated.
    24122425 *
    24132426 * @return converted name. NULL pointer on failure. Caller needs to free.
     
    24242437        char *name;
    24252438        char *p;
     2439        char *result;
    24262440
    24272441        /* This cannot work when the winbind separator = @ */
     
    24552469        }
    24562470
    2457         return talloc_asprintf(ctx, "%s%c%s", domain, sep, name);
     2471        result = talloc_asprintf(ctx, "%s%c%s", domain, sep, name);
     2472        wbcFreeMemory(domain);
     2473        wbcFreeMemory(name);
     2474        return result;
    24582475}
    24592476
    24602477static int _pam_delete_cred(pam_handle_t *pamh, int flags,
    2461                          int argc, const char **argv)
     2478                            int argc, enum pam_winbind_request_type type,
     2479                            const char **argv)
    24622480{
    24632481        int retval = PAM_SUCCESS;
     
    24702488        ZERO_STRUCT(logoff);
    24712489
    2472         retval = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2473         if (retval) {
    2474                 goto out;
     2490        retval = _pam_winbind_init_context(pamh, flags, argc, argv, type, &ctx);
     2491        if (retval != PAM_SUCCESS) {
     2492                return retval;
    24752493        }
    24762494
     
    24862504
    24872505                retval = pam_get_user(pamh, &user, _("Username: "));
    2488                 if (retval) {
     2506                if (retval != PAM_SUCCESS) {
    24892507                        _pam_log(ctx, LOG_ERR,
    24902508                                 "could not identify user");
     
    25242542                                                     "ccfilename",
    25252543                                                     0,
    2526                                                      (uint8_t *)ccname,
     2544                                                     discard_const_p(uint8_t, ccname),
    25272545                                                     strlen(ccname)+1);
    25282546                        if (!WBC_ERROR_IS_OK(wbc_status)) {
     
    26052623        struct pwb_context *ctx = NULL;
    26062624
    2607         retval = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2608         if (retval) {
    2609                 goto out;
     2625        retval = _pam_winbind_init_context(pamh, flags, argc, argv,
     2626                                           PAM_WINBIND_AUTHENTICATE, &ctx);
     2627        if (retval != PAM_SUCCESS) {
     2628                return retval;
    26102629        }
    26112630
     
    27422761        }
    27432762
    2744         if (ctx != NULL) {
    2745                 _PAM_LOG_FUNCTION_LEAVE("pam_sm_authenticate", ctx, retval);
    2746                 TALLOC_FREE(ctx);
    2747         }
     2763        _PAM_LOG_FUNCTION_LEAVE("pam_sm_authenticate", ctx, retval);
     2764
     2765        TALLOC_FREE(ctx);
    27482766
    27492767        return retval;
     
    27572775        struct pwb_context *ctx = NULL;
    27582776
    2759         ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2760         if (ret) {
    2761                 goto out;
     2777        ret = _pam_winbind_init_context(pamh, flags, argc, argv,
     2778                                        PAM_WINBIND_SETCRED, &ctx);
     2779        if (ret != PAM_SUCCESS) {
     2780                return ret;
    27622781        }
    27632782
     
    27672786
    27682787                case PAM_DELETE_CRED:
    2769                         ret = _pam_delete_cred(pamh, flags, argc, argv);
     2788                        ret = _pam_delete_cred(pamh, flags, argc,
     2789                                               PAM_WINBIND_SETCRED, argv);
    27702790                        break;
    27712791                case PAM_REFRESH_CRED:
     
    27892809        }
    27902810
    2791  out:
    2792 
    27932811        _PAM_LOG_FUNCTION_LEAVE("pam_sm_setcred", ctx, ret);
    27942812
     
    28082826        const char *username;
    28092827        int ret = PAM_USER_UNKNOWN;
    2810         void *tmp = NULL;
     2828        const char *tmp = NULL;
    28112829        struct pwb_context *ctx = NULL;
    28122830
    2813         ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2814         if (ret) {
    2815                 goto out;
     2831        ret = _pam_winbind_init_context(pamh, flags, argc, argv,
     2832                                        PAM_WINBIND_ACCT_MGMT, &ctx);
     2833        if (ret != PAM_SUCCESS) {
     2834                return ret;
    28162835        }
    28172836
     
    28492868                             (const void **)&tmp);
    28502869                if (tmp != NULL) {
    2851                         ret = atoi((const char *)tmp);
     2870                        ret = atoi(tmp);
    28522871                        switch (ret) {
    28532872                        case PAM_AUTHTOK_EXPIRED:
     
    29062925        struct pwb_context *ctx = NULL;
    29072926
    2908         ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2909         if (ret) {
    2910                 goto out;
     2927        ret = _pam_winbind_init_context(pamh, flags, argc, argv,
     2928                                        PAM_WINBIND_OPEN_SESSION, &ctx);
     2929        if (ret != PAM_SUCCESS) {
     2930                return ret;
    29112931        }
    29122932
     
    29172937                ret = _pam_mkhomedir(ctx);
    29182938        }
    2919  out:
     2939
    29202940        _PAM_LOG_FUNCTION_LEAVE("pam_sm_open_session", ctx, ret);
    29212941
     
    29322952        struct pwb_context *ctx = NULL;
    29332953
    2934         ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    2935         if (ret) {
    2936                 goto out;
     2954        ret = _pam_winbind_init_context(pamh, flags, argc, argv,
     2955                                        PAM_WINBIND_CLOSE_SESSION, &ctx);
     2956        if (ret != PAM_SUCCESS) {
     2957                return ret;
    29372958        }
    29382959
    29392960        _PAM_LOG_FUNCTION_ENTER("pam_sm_close_session", ctx);
    29402961
    2941 out:
    29422962        _PAM_LOG_FUNCTION_LEAVE("pam_sm_close_session", ctx, ret);
    29432963
     
    29752995        struct passwd *pwd = NULL;
    29762996
    2977         _pam_get_data(ctx->pamh, PAM_WINBIND_NEW_AUTHTOK_REQD_DURING_AUTH,
    2978                       &new_authtok_reqd_during_auth);
     2997        pam_get_data(ctx->pamh, PAM_WINBIND_NEW_AUTHTOK_REQD_DURING_AUTH,
     2998                      (const void **) &new_authtok_reqd_during_auth);
    29792999        pam_set_data(ctx->pamh, PAM_WINBIND_NEW_AUTHTOK_REQD_DURING_AUTH,
    29803000                     NULL, NULL);
     
    30073027        /* <DO NOT free() THESE> */
    30083028        const char *user;
    3009         char *pass_old, *pass_new;
     3029        const char *pass_old;
     3030        const char *pass_new;
    30103031        /* </DO NOT free() THESE> */
    30113032
     
    30173038        struct pwb_context *ctx = NULL;
    30183039
    3019         ret = _pam_winbind_init_context(pamh, flags, argc, argv, &ctx);
    3020         if (ret) {
    3021                 goto out;
     3040        ret = _pam_winbind_init_context(pamh, flags, argc, argv,
     3041                                        PAM_WINBIND_CHAUTHTOK, &ctx);
     3042        if (ret != PAM_SUCCESS) {
     3043                return ret;
    30223044        }
    30233045
     
    30333055         */
    30343056        ret = pam_get_user(pamh, &user, _("Username: "));
    3035         if (ret) {
     3057        if (ret != PAM_SUCCESS) {
    30363058                _pam_log(ctx, LOG_ERR,
    30373059                         "password - could not identify user");
     
    31303152                 */
    31313153
    3132                 ret = _pam_get_item(pamh, PAM_OLDAUTHTOK, &pass_old);
     3154                ret = pam_get_item(pamh, PAM_OLDAUTHTOK, (const void **) &pass_old);
    31333155
    31343156                if (ret != PAM_SUCCESS) {
     
    31803202                 * rebuild the password database file.
    31813203                 */
    3182                 _pam_get_data(pamh, PAM_WINBIND_PWD_LAST_SET,
    3183                               &pwdlastset_update);
     3204                pam_get_data(pamh, PAM_WINBIND_PWD_LAST_SET,
     3205                             (const void **) &pwdlastset_update);
    31843206
    31853207                /*
     
    31943216                ret = winbind_chauthtok_request(ctx, user, pass_old,
    31953217                                                pass_new, pwdlastset_update);
    3196                 if (ret) {
     3218                if (ret != PAM_SUCCESS) {
    31973219                        pass_old = pass_new = NULL;
    31983220                        goto out;
Note: See TracChangeset for help on using the changeset viewer.