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.