Changeset 25 in openpam


Ignore:
Timestamp:
Feb 4, 2002, 3:00:16 PM (13 years ago)
Author:
des
Message:

Store options, and pass them to modules.

Replace the "dispatching" flag with a pam_chain_t pointer. It is set
to point at the currently executing module right before calling the
module, and cleared right after the module returns. Note that this
isn't intended to prevent reentrancy in multi-threaded applications,
but simply to prevent modules from using the application interface.

When recursion is detected, return PAM_ABORT rather than
PAM_SYSTEM_ERR, since this is a programmatical error rather than
a runtime one.

Sponsored by: DARPA, NAI Labs

Location:
trunk/lib
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/openpam_dispatch.c

    r20 r25  
    6363 
    6464        /* prevent recursion */ 
    65         if (pamh->dispatching) { 
     65        if (pamh->current != NULL) { 
    6666                openpam_log(PAM_LOG_ERROR, "indirect recursion"); 
    67                 return (PAM_SYSTEM_ERR); 
    68         } 
    69         pamh->dispatching = 1; 
     67                return (PAM_ABORT); 
     68        } 
    7069 
    7170        /* pick a chain */ 
     
    8685                break; 
    8786        default: 
    88                 pamh->dispatching = 0; 
    8987                return (PAM_SYSTEM_ERR); 
    9088        } 
     
    9997                        openpam_log(PAM_LOG_ERROR, "%s: no %s()", 
    10098                            module->modpath, _pam_sm_func_name[primitive]); 
    101                         pamh->dispatching = 0; 
    10299                        r = PAM_SYMBOL_ERR; 
    103100                } else { 
    104                         r = (module->primitive[primitive])(pamh, flags); 
     101                        pamh->current = module; 
     102                        r = (module->primitive[primitive])(pamh, flags, 
     103                            module->optc, (const char **)module->optv); 
     104                        pamh->current = NULL; 
    105105                        openpam_log(PAM_LOG_DEBUG, "%s: %s(): %s", 
    106106                            module->modpath, _pam_sm_func_name[primitive], 
     
    148148        } 
    149149 
    150         pamh->dispatching = 0; 
    151150        return (fail ? err : PAM_SUCCESS); 
    152151} 
  • trunk/lib/openpam_impl.h

    r21 r25  
    6868extern const char *_pam_sm_func_name[PAM_NUM_PRIMITIVES]; 
    6969 
    70 typedef int (*pam_func_t)(pam_handle_t *, int); 
     70typedef int (*pam_func_t)(pam_handle_t *, int, int, const char **); 
    7171 
    7272typedef struct pam_chain pam_chain_t; 
     
    7474        int              flag; 
    7575        char            *modpath; 
    76         /* XXX options */ 
     76        int              optc; 
     77        char           **optv; 
    7778        pam_chain_t     *next; 
    7879        void            *dlh; 
     
    9293struct pam_handle { 
    9394        char            *service; 
    94         int              dispatching; 
    9595 
    9696        /* chains */ 
    9797        pam_chain_t     *chains[PAM_NUM_CHAINS]; 
     98        pam_chain_t     *current; 
    9899 
    99100        /* items and data */ 
     
    112113int             openpam_findenv(pam_handle_t *, const char *, size_t); 
    113114int             openpam_add_module(pam_handle_t *, int, int, 
    114                                    const char *, const char *); 
     115                                   const char *, int, const char **); 
    115116void            openpam_clear_chains(pam_handle_t *); 
    116117 
  • trunk/lib/openpam_load.c

    r22 r25  
    5252}; 
    5353 
     54static void 
     55openpam_destroy_module(pam_chain_t *module) 
     56{ 
     57        if (module->dlh != NULL) 
     58                dlclose(module->dlh); 
     59        while (module->optc--) 
     60                free(module->optv[module->optc]); 
     61        free(module->optv); 
     62        free(module->modpath); 
     63        free(module); 
     64} 
     65 
    5466int 
    5567openpam_add_module(pam_handle_t *pamh, 
     
    5769        int flag, 
    5870        const char *modpath, 
    59         const char *options /* XXX */ __unused) 
     71        int optc, 
     72        const char *optv[]) 
    6073{ 
    6174        pam_chain_t *module, *iterator; 
     
    6376 
    6477        /* fill in configuration data */ 
    65         if ((module = malloc(sizeof(*module))) == NULL) { 
    66                 openpam_log(PAM_LOG_ERROR, "malloc(): %m"); 
    67                 return (PAM_BUF_ERR); 
    68         } 
    69         if ((module->modpath = strdup(modpath)) == NULL) { 
    70                 openpam_log(PAM_LOG_ERROR, "strdup(): %m"); 
    71                 free(module); 
    72                 return (PAM_BUF_ERR); 
    73         } 
     78        if ((module = calloc(1, sizeof(*module))) == NULL) 
     79                goto buf_err; 
     80        if ((module->modpath = strdup(modpath)) == NULL) 
     81                goto buf_err; 
     82        if ((module->optv = malloc(sizeof(char *) * (optc + 1))) == NULL) 
     83                goto buf_err; 
     84        while (optc--) 
     85                if ((module->optv[module->optc++] = strdup(*optv++)) == NULL) 
     86                        goto buf_err; 
     87        module->optv[module->optc] = NULL; 
    7488        module->flag = flag; 
    7589        module->next = NULL; 
     
    88102        if ((module->dlh = dlopen(modpath, RTLD_NOW)) == NULL) { 
    89103                openpam_log(PAM_LOG_ERROR, "dlopen(): %s", dlerror()); 
    90                 free(module->modpath); 
    91                 free(module); 
     104                openpam_destroy_module(module); 
    92105                return (PAM_OPEN_ERR); 
    93106        } 
     
    104117        } 
    105118        return (PAM_SUCCESS); 
     119 
     120 buf_err: 
     121        openpam_log(PAM_LOG_ERROR, "%m"); 
     122        openpam_destroy_module(module); 
     123        return (PAM_BUF_ERR); 
    106124} 
    107125 
     
    120138                        module = pamh->chains[i]; 
    121139                        pamh->chains[i] = module->next; 
    122                         /* XXX free options */ 
    123                         dlclose(module->dlh); 
    124                         free(module->modpath); 
    125                         free(module); 
     140                        openpam_destroy_module(module); 
    126141                } 
    127142        } 
  • trunk/lib/pam_start.c

    r21 r25  
    9090#define PAM_D_STYLE     1 
    9191#define MAX_LINE_LEN    1024 
     92#define MAX_OPTIONS     256 
    9293 
    9394static int 
     
    9899{ 
    99100        char buf[MAX_LINE_LEN], *p, *q; 
    100         int ch, chain, flag, line, n, r; 
     101        const char *optv[MAX_OPTIONS + 1]; 
     102        int ch, chain, flag, line, optc, n, r; 
    101103        size_t len; 
    102104        FILE *f; 
     
    207209 
    208210                /* get options */ 
    209                 if (*q != '\0') { 
    210                         *q++ = 0; 
     211                for (optc = 0; *q != '\0' && optc < MAX_OPTIONS; ++optc) { 
     212                        *q++ = '\0'; 
    211213                        while (isspace(*q)) 
    212214                                ++q; 
     215                        optv[optc] = q; 
     216                        while (*q != '\0' && !isspace(*q)) 
     217                                ++q; 
     218                } 
     219                optv[optc] = NULL; 
     220                if (*q != '\0') { 
     221                        *q = '\0'; 
     222                        openpam_log(PAM_LOG_ERROR, 
     223                            "%s: too many options on line %d", 
     224                            filename, line); 
    213225                } 
    214226 
     
    217229                 * appropriate chain and bump the counter. 
    218230                 */ 
    219                 if ((r = openpam_add_module(pamh, chain, flag, p, q)) != 
    220                     PAM_SUCCESS) 
     231                r = openpam_add_module(pamh, chain, flag, p, optc, optv); 
     232                if (r != PAM_SUCCESS) 
    221233                        return (-r); 
    222234                ++n; 
Note: See TracChangeset for help on using the changeset viewer.