granicus.if.org Git - linux-pam/blob - libpam_misc/misc_conv.c

   1 /*
   2  * $Id$
   3  *
   4  * A generic conversation function for text based applications
   5  *
   6  * Written by Andrew Morgan <morgan@linux.kernel.org>
   7  */
   8
   9 #include <security/_pam_aconf.h>
  10
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/types.h>
  16 #include <termios.h>
  17 #include <time.h>
  18 #include <unistd.h>
  19
  20 #include <security/pam_appl.h>
  21 #include <security/pam_misc.h>
  22
  23 #define INPUTSIZE PAM_MAX_MSG_SIZE           /* maximum length of input+1 */
  24 #define CONV_ECHO_ON  1                            /* types of echo state */
  25 #define CONV_ECHO_OFF 0
  26
  27 /*
  28  * external timeout definitions - these can be overriden by the
  29  * application.
  30  */
  31
  32 time_t pam_misc_conv_warn_time = 0;                  /* time when we warn */
  33 time_t pam_misc_conv_die_time  = 0;               /* time when we timeout */
  34
  35 const char *pam_misc_conv_warn_line = "..\a.Time is running out...\n";
  36 const char *pam_misc_conv_die_line  = "..\a.Sorry, your time is up!\n";
  37
  38 int pam_misc_conv_died=0;       /* application can probe this for timeout */
  39
  40 /*
  41  * These functions are for binary prompt manipulation.
  42  * The manner in which a binary prompt is processed is application
  43  * specific, so these function pointers are provided and can be
  44  * initialized by the application prior to the conversation function
  45  * being used.
  46  */
  47
  48 static void pam_misc_conv_delete_binary(void *appdata,
  49                                         pamc_bp_t *delete_me)
  50 {
  51     PAM_BP_RENEW(delete_me, 0, 0);
  52 }
  53
  54 int (*pam_binary_handler_fn)(void *appdata, pamc_bp_t *prompt_p) = NULL;
  55 void (*pam_binary_handler_free)(void *appdata, pamc_bp_t *prompt_p)
  56       = pam_misc_conv_delete_binary;
  57
  58 /* the following code is used to get text input */
  59
  60 static volatile int expired=0;
  61
  62 /* return to the previous signal handling */
  63 static void reset_alarm(struct sigaction *o_ptr)
  64 {
  65     (void) alarm(0);                 /* stop alarm clock - if still ticking */
  66     (void) sigaction(SIGALRM, o_ptr, NULL);
  67 }
  68
  69 /* this is where we intercept the alarm signal */
  70 static void time_is_up(int ignore)
  71 {
  72     expired = 1;
  73 }
  74
  75 /* set the new alarm to hit the time_is_up() function */
  76 static int set_alarm(int delay, struct sigaction *o_ptr)
  77 {
  78     struct sigaction new_sig;
  79
  80     sigemptyset(&new_sig.sa_mask);
  81     new_sig.sa_flags = 0;
  82     new_sig.sa_handler = time_is_up;
  83     if ( sigaction(SIGALRM, &new_sig, o_ptr) ) {
  84         return 1;         /* setting signal failed */
  85     }
  86     if ( alarm(delay) ) {
  87         (void) sigaction(SIGALRM, o_ptr, NULL);
  88         return 1;         /* failed to set alarm */
  89     }
  90     return 0;             /* all seems to have worked */
  91 }
  92
  93 /* return the number of seconds to next alarm. 0 = no delay, -1 = expired */
  94 static int get_delay(void)
  95 {
  96     time_t now;
  97
  98     expired = 0;                                        /* reset flag */
  99     (void) time(&now);
 100
 101     /* has the quit time past? */
 102     if (pam_misc_conv_die_time && now >= pam_misc_conv_die_time) {
 103         fprintf(stderr,"%s",pam_misc_conv_die_line);
 104
 105         pam_misc_conv_died = 1;       /* note we do not reset the die_time */
 106         return -1;                                           /* time is up */
 107     }
 108
 109     /* has the warning time past? */
 110     if (pam_misc_conv_warn_time && now >= pam_misc_conv_warn_time) {
 111         fprintf(stderr, "%s", pam_misc_conv_warn_line);
 112         pam_misc_conv_warn_time = 0;                    /* reset warn_time */
 113
 114         /* indicate remaining delay - if any */
 115
 116         return (pam_misc_conv_die_time ? pam_misc_conv_die_time - now:0 );
 117     }
 118
 119     /* indicate possible warning delay */
 120
 121     if (pam_misc_conv_warn_time)
 122         return (pam_misc_conv_warn_time - now);
 123     else if (pam_misc_conv_die_time)
 124         return (pam_misc_conv_die_time - now);
 125     else
 126         return 0;
 127 }
 128
 129 /* read a line of input string, giving prompt when appropriate */
 130 static char *read_string(int echo, const char *prompt)
 131 {
 132     struct termios term_before, term_tmp;
 133     char line[INPUTSIZE], *input;
 134     struct sigaction old_sig;
 135     int delay, nc, have_term=0;
 136     sigset_t oset, nset;
 137
 138     D(("called with echo='%s', prompt='%s'.", echo ? "ON":"OFF" , prompt));
 139
 140     input = line;
 141
 142     if (isatty(STDIN_FILENO)) {                      /* terminal state */
 143
 144         /* is a terminal so record settings and flush it */
 145         if ( tcgetattr(STDIN_FILENO, &term_before) != 0 ) {
 146             D(("<error: failed to get terminal settings>"));
 147             return NULL;
 148         }
 149         memcpy(&term_tmp, &term_before, sizeof(term_tmp));
 150         if (!echo) {
 151             term_tmp.c_lflag &= ~(ECHO);
 152         }
 153         have_term = 1;
 154
 155         /*
 156          * We make a simple attempt to block TTY signals from terminating
 157          * the conversation without giving PAM a chance to clean up.
 158          */
 159
 160         sigemptyset(&nset);
 161         sigaddset(&nset, SIGINT);
 162         sigaddset(&nset, SIGTSTP);
 163         (void) sigprocmask(SIG_BLOCK, &nset, &oset);
 164
 165     } else if (!echo) {
 166         D(("<warning: cannot turn echo off>"));
 167     }
 168
 169     /* set up the signal handling */
 170     delay = get_delay();
 171
 172     /* reading the line */
 173     while (delay >= 0) {
 174
 175         fprintf(stderr, "%s", prompt);
 176         /* this may, or may not set echo off -- drop pending input */
 177         if (have_term)
 178             (void) tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_tmp);
 179
 180         if ( delay > 0 && set_alarm(delay, &old_sig) ) {
 181             D(("<failed to set alarm>"));
 182             break;
 183         } else {
 184             nc = read(STDIN_FILENO, line, INPUTSIZE-1);
 185             if (have_term) {
 186                 (void) tcsetattr(STDIN_FILENO, TCSADRAIN, &term_before);
 187                 if (!echo || expired)             /* do we need a newline? */
 188                     fprintf(stderr,"\n");
 189             }
 190             if ( delay > 0 ) {
 191                 reset_alarm(&old_sig);
 192             }
 193             if (expired) {
 194                 delay = get_delay();
 195             } else if (nc > 0) {                 /* we got some user input */
 196                 D(("we got some user input"));
 197
 198                 if (nc > 0 && line[nc-1] == '\n') {     /* <NUL> terminate */
 199                     line[--nc] = '\0';
 200                 } else {
 201                     if (echo) {
 202                         fprintf(stderr, "\n");
 203                     }
 204                     line[nc] = '\0';
 205                 }
 206                 input = x_strdup(line);
 207                 _pam_overwrite(line);
 208
 209                 goto cleanexit;                /* return malloc()ed string */
 210
 211             } else if (nc == 0) {                                /* Ctrl-D */
 212                 D(("user did not want to type anything"));
 213
 214                 input = x_strdup("");
 215                 if (echo) {
 216                     fprintf(stderr, "\n");
 217                 }
 218                 goto cleanexit;                /* return malloc()ed "" */
 219             }
 220         }
 221     }
 222
 223     /* getting here implies that the timer expired */
 224
 225     D(("the timer appears to have expired"));
 226
 227     input = NULL;
 228     _pam_overwrite(line);
 229
 230  cleanexit:
 231
 232     if (have_term) {
 233         (void) sigprocmask(SIG_SETMASK, &oset, NULL);
 234         (void) tcsetattr(STDIN_FILENO, TCSADRAIN, &term_before);
 235     }
 236
 237     D(("returning [%s]", input));
 238
 239     return input;
 240 }
 241
 242 /* end of read_string functions */
 243
 244 /*
 245  * This conversation function is supposed to be a generic PAM one.
 246  * Unfortunately, it is _not_ completely compatible with the Solaris PAM
 247  * codebase.
 248  *
 249  * Namely, for msgm's that contain multiple prompts, this function
 250  * interprets "const struct pam_message **msgm" as equivalent to
 251  * "const struct pam_message *msgm[]". The Solaris module
 252  * implementation interprets the **msgm object as a pointer to a
 253  * pointer to an array of "struct pam_message" objects (that is, a
 254  * confusing amount of pointer indirection).
 255  */
 256
 257 int misc_conv(int num_msg, const struct pam_message **msgm,
 258               struct pam_response **response, void *appdata_ptr)
 259 {
 260     int count=0;
 261     struct pam_response *reply;
 262
 263     if (num_msg <= 0)
 264         return PAM_CONV_ERR;
 265
 266     D(("allocating empty response structure array."));
 267
 268     reply = (struct pam_response *) calloc(num_msg,
 269                                            sizeof(struct pam_response));
 270     if (reply == NULL) {
 271         D(("no memory for responses"));
 272         return PAM_CONV_ERR;
 273     }
 274
 275     D(("entering conversation function."));
 276
 277     for (count=0; count < num_msg; ++count) {
 278         char *string=NULL;
 279
 280         switch (msgm[count]->msg_style) {
 281         case PAM_PROMPT_ECHO_OFF:
 282             string = read_string(CONV_ECHO_OFF,msgm[count]->msg);
 283             if (string == NULL) {
 284                 goto failed_conversation;
 285             }
 286             break;
 287         case PAM_PROMPT_ECHO_ON:
 288             string = read_string(CONV_ECHO_ON,msgm[count]->msg);
 289             if (string == NULL) {
 290                 goto failed_conversation;
 291             }
 292             break;
 293         case PAM_ERROR_MSG:
 294             if (fprintf(stderr,"%s\n",msgm[count]->msg) < 0) {
 295                 goto failed_conversation;
 296             }
 297             break;
 298         case PAM_TEXT_INFO:
 299             if (fprintf(stdout,"%s\n",msgm[count]->msg) < 0) {
 300                 goto failed_conversation;
 301             }
 302             break;
 303         case PAM_BINARY_PROMPT:
 304         {
 305             pamc_bp_t binary_prompt = NULL;
 306
 307             if (!msgm[count]->msg || !pam_binary_handler_fn) {
 308                 goto failed_conversation;
 309             }
 310
 311             PAM_BP_RENEW(&binary_prompt,
 312                          PAM_BP_RCONTROL(msgm[count]->msg),
 313                          PAM_BP_LENGTH(msgm[count]->msg));
 314             PAM_BP_FILL(binary_prompt, 0, PAM_BP_LENGTH(msgm[count]->msg),
 315                         PAM_BP_RDATA(msgm[count]->msg));
 316
 317             if (pam_binary_handler_fn(appdata_ptr,
 318                                       &binary_prompt) != PAM_SUCCESS
 319                 || (binary_prompt == NULL)) {
 320                 goto failed_conversation;
 321             }
 322             string = (char *) binary_prompt;
 323             binary_prompt = NULL;
 324
 325             break;
 326         }
 327         default:
 328             fprintf(stderr, "erroneous conversation (%d)\n"
 329                     ,msgm[count]->msg_style);
 330             goto failed_conversation;
 331         }
 332
 333         if (string) {                         /* must add to reply array */
 334             /* add string to list of responses */
 335
 336             reply[count].resp_retcode = 0;
 337             reply[count].resp = string;
 338             string = NULL;
 339         }
 340     }
 341
 342     *response = reply;
 343     reply = NULL;
 344
 345     return PAM_SUCCESS;
 346
 347 failed_conversation:
 348
 349     D(("the conversation failed"));
 350
 351     if (reply) {
 352         for (count=0; count<num_msg; ++count) {
 353             if (reply[count].resp == NULL) {
 354                 continue;
 355             }
 356             switch (msgm[count]->msg_style) {
 357             case PAM_PROMPT_ECHO_ON:
 358             case PAM_PROMPT_ECHO_OFF:
 359                 _pam_overwrite(reply[count].resp);
 360                 free(reply[count].resp);
 361                 break;
 362             case PAM_BINARY_PROMPT:
 363                 pam_binary_handler_free(appdata_ptr,
 364                                         (pamc_bp_t *) &reply[count].resp);
 365                 break;
 366             case PAM_ERROR_MSG:
 367             case PAM_TEXT_INFO:
 368                 /* should not actually be able to get here... */
 369                 free(reply[count].resp);
 370             }
 371             reply[count].resp = NULL;
 372         }
 373         /* forget reply too */
 374         free(reply);
 375         reply = NULL;
 376     }
 377
 378     return PAM_CONV_ERR;
 379 }
 380