Changeset 2457 for neercs


Ignore:
Timestamp:
Jun 19, 2008, 2:23:46 PM (12 years ago)
Author:
Jean-Yves Lamoureux
Message:
  • Added lock-screen bugWfeature using PAM (likely to work only with passwords yet)
  • Removed this UGLY space character SOMEONE left on the configure.ac. THAT WAS HORRIIIIIBLE.
Location:
neercs/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • neercs/trunk/configure.ac

    r2455 r2457  
    3232  AC_MSG_ERROR([you need libcaca version 0.99.beta13 or later])])
    3333
    34 AC_CHECK_HEADERS(stdio.h pty.h sys/ioctl.h sys/ptrace.h sys/stat.h sys/syscall.h sys/user.h sys/wait.h linux/kdev_t.h linux/major.h)
     34AC_CHECK_HEADERS(stdio.h pty.h sys/ioctl.h sys/ptrace.h sys/stat.h sys/syscall.h sys/user.h sys/wait.h linux/kdev_t.h linux/major.h security/pam_appl.h security/pam_misc.h)
     35
     36AC_CHECK_LIB(pam, pam_authenticate, PAM_LIBS="${PAM_LIBS} -lpam")
     37AC_SUBST(PAM_LIBS)
     38
    3539
    3640AC_CHECK_LIB(util, forkpty, UTIL_LIBS="${UTIL_LIBS} -lutil")
    3741AC_SUBST(UTIL_LIBS)
    3842
    39 case $target_cpu in 
     43case $target_cpu in
    4044  i?86)
    4145    case $target_os in
     
    4347      *) grab=no;;
    4448    esac;;
    45   *)    grab=no;; 
    46 esac 
     49  *)    grab=no;;
     50esac
    4751
    4852if test "$grab" = "yes"; then
  • neercs/trunk/src/Makefile.am

    r2455 r2457  
    55                 grab.c effects.c wm.c screensaver.c
    66neercs_CFLAGS = @CACA_CFLAGS@
    7 neercs_LDADD = @CACA_LIBS@ @UTIL_LIBS@
     7neercs_LDADD = @CACA_LIBS@ @UTIL_LIBS@ @PAM_LIBS@
    88
  • neercs/trunk/src/effects.c

    r2446 r2457  
    2121#include <config.h>
    2222#include <time.h>
     23#include <sys/wait.h>
     24#include <sys/types.h>
     25#include <security/pam_appl.h>
     26#include <security/pam_misc.h>
     27#include <pwd.h>
    2328
    2429#include "neercs.h"
    2530
     31static int convpam(int num_msg, const struct pam_message **msg,
     32        struct pam_response **resp, void *appdata_ptr);
    2633
    2734void draw_thumbnails(cucul_canvas_t *cv, struct screen_list *screen_list)
     
    211218
    212219
     220void draw_lock(cucul_canvas_t *cv, struct screen_list *screen_list)
     221{
     222    unsigned int i;
     223    char buffer[1024];
     224    gethostname(buffer, sizeof(buffer)-1);
     225
     226    int w = 65, h = 20;
     227    int x = (cucul_get_canvas_width(cv) - w) / 2;
     228    int y = (cucul_get_canvas_height(cv) - h) / 2;
     229
     230
     231    cucul_set_color_ansi(cv, CUCUL_BLUE, CUCUL_BLUE);
     232    cucul_fill_box(cv,
     233                   x, y,
     234                   w, h, '#');
     235    cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_BLUE);
     236    cucul_draw_cp437_box(cv,
     237                         x, y,
     238                         w, h);
     239
     240    x+=2;
     241    y++;
     242    cucul_printf(cv,
     243                 (cucul_get_canvas_width(cv) - strlen(PACKAGE_STRING " locked")) / 2,
     244                 y-1,
     245                 PACKAGE_STRING " locked");
     246
     247    cucul_printf(cv, x, y++, "Please type in your password for %s@%s :", getenv("USER"), buffer);
     248    y+=2;
     249
     250    x = (cucul_get_canvas_width(cv)/2) - ((strlen(screen_list->lockpass) / 2) + strlen("Password : "));
     251    cucul_printf(cv, x, y, "Password : ");
     252    x+=strlen("Password : ");
     253    for(i=0; i<strlen(screen_list->lockpass); i++)
     254    {
     255        cucul_put_str(cv, x, y, "*");
     256        x++;
     257    }
     258
     259
     260    if(strlen(screen_list->lockmsg))
     261    {
     262        x = ((cucul_get_canvas_width(cv) - w) / 2) + (strlen(screen_list->lockmsg));
     263        y+=2;
     264        cucul_set_color_ansi(cv, CUCUL_RED, CUCUL_BLUE);
     265        cucul_printf(cv, x, y, "Error : %s", screen_list->lockmsg);
     266    }
     267}
     268
     269
     270
     271/* FIXME, handle this without assuming this is a password auth */
     272static int convpam(int num_msg, const struct pam_message **msg,
     273                struct pam_response **resp, void *appdata_ptr)
     274{
     275
     276    struct pam_response *aresp;
     277    int i;
     278    aresp = calloc(num_msg, sizeof(*aresp));
     279
     280    for (i = 0; i < num_msg; ++i)
     281    {
     282        switch(msg[i]->msg_style)
     283        {
     284        case PAM_PROMPT_ECHO_ON:
     285        case PAM_PROMPT_ECHO_OFF:
     286            aresp[i].resp = strdup(appdata_ptr);
     287            aresp[i].resp_retcode = 0;
     288            break;
     289        case PAM_ERROR_MSG:
     290            break;
     291        default :
     292            printf("Unknow message type from PAM\n");
     293            break;
     294        }
     295    }
     296
     297    *resp = aresp;
     298    return (PAM_SUCCESS);
     299
     300}
     301
     302
     303int validate_lock(struct screen_list *screen_list, char *user, char *pass)
     304{
     305    int ret;
     306    pam_handle_t *pamh=NULL;
     307    char buffer[100];
     308    const char *service="neercs";
     309    struct pam_conv conv = {
     310        convpam,
     311        pass,
     312    };
     313
     314    ret = pam_start(service, user, &conv, &pamh);
     315    if(ret!=PAM_SUCCESS)
     316        return 0;
     317    pam_set_item(pamh, PAM_RUSER, user);
     318
     319    ret = gethostname(buffer, sizeof(buffer)-1);
     320    if (ret) {
     321        perror("failed to look up hostname");
     322        ret = pam_end(pamh, PAM_ABORT);
     323        sprintf(screen_list->lockmsg, "Can't get hostname");
     324        pam_end(pamh, PAM_SUCCESS);
     325        return 0;
     326    }
     327
     328    ret = pam_set_item(pamh, PAM_RHOST, buffer);
     329    if(ret!=PAM_SUCCESS)
     330    {
     331        sprintf(screen_list->lockmsg, "Can't set hostname");
     332        pam_end(pamh, PAM_SUCCESS);
     333        return 0;
     334    }
     335
     336    ret = pam_authenticate(pamh, 0);
     337    if(ret!=PAM_SUCCESS)
     338    {
     339        sprintf(screen_list->lockmsg, "Can't authenticate");
     340        pam_end(pamh, PAM_SUCCESS);
     341        return 0;
     342    }
     343
     344    ret = pam_end(pamh, PAM_SUCCESS);
     345    return 1;
     346}
    213347
    214348
  • neercs/trunk/src/main.c

    r2456 r2457  
    7575    int eof = 0, refresh = 1, command = 0;
    7676    long long unsigned int last_key_time = 0;
     77    int lock_offset = 0;
    7778
    7879    default_shell = getenv("SHELL");
     
    125126    screen_list->screensaver_data = NULL;
    126127    screen_list->in_screensaver = 0;
     128    screen_list->locked = 0;
     129    memset(screen_list->lockmsg, 0, 1024);
     130    memset(screen_list->lockpass, 0, 1024);
    127131
    128132    recurrent_list = (struct recurrent_list*) malloc(sizeof(struct recurrent_list));
     
    215219        {
    216220            unsigned int c = caca_get_event_key_ch(&ev);
    217 
    218221            if(command)
    219222            {
     
    265268                    refresh = 1;
    266269                    break;
     270                case 'x':
     271                case 0x18: //CACA_KEY_CTRL_X:
     272                    memset(screen_list->lockpass, 0, 1024);
     273                    screen_list->locked = 1;
     274                    lock_offset = 0;
     275                    refresh = 1;
     276                    break;
    267277                case 'h':
    268278                case 0x08: //CACA_KEY_CTRL_H:
     
    285295                    continue;
    286296                }
    287 
    288 
    289                 switch(c)
     297                else if(screen_list->locked)
    290298                {
    291                 case 0x01: //CACA_KEY_CTRL_A:
    292                     command = 1; break;
    293                 case CACA_KEY_UP:
    294                     write(screen_list->screen[screen_list->pty]->fd, "\x1b[A", 3); break;
    295                 case CACA_KEY_DOWN:
    296                     write(screen_list->screen[screen_list->pty]->fd, "\x1b[B", 3); break;
    297                 case CACA_KEY_RIGHT:
    298                     write(screen_list->screen[screen_list->pty]->fd, "\x1b[C", 3); break;
    299                 case CACA_KEY_LEFT:
    300                     write(screen_list->screen[screen_list->pty]->fd, "\x1b[D", 3); break;
    301                 case CACA_KEY_ESCAPE:
    302                     if(screen_list->help)
     299                    if(c==0x08)
    303300                    {
    304                         screen_list->help = 0;
    305                         refresh = 1;
    306                         break;
     301                        if(lock_offset)
     302                        {
     303                            screen_list->lockpass[lock_offset-1] = 0;
     304                            lock_offset--;
     305                        }
    307306                    }
    308                 default:
    309                     write(screen_list->screen[screen_list->pty]->fd, &c, 1); break;
     307                    else if(c==0x0d) // RETURN
     308                    {
     309                        memset(screen_list->lockmsg, 0, 1024);
     310                        if(validate_lock(screen_list, getenv("USER"), screen_list->lockpass))
     311                        {
     312                            memset(screen_list->lockpass, 0, 1024);
     313                            screen_list->locked = 0;
     314                            lock_offset = 0;
     315                            refresh = 1;
     316                        }
     317                        else
     318                        {
     319                            memset(screen_list->lockpass, 0, 1024);
     320                            lock_offset = 0;
     321                            refresh = 1;
     322                        }
     323                    }
     324                    else
     325                    {
     326                        if(lock_offset < 1023)
     327                        {
     328                            screen_list->lockpass[lock_offset++] = c;
     329                            screen_list->lockpass[lock_offset]   = 0;
     330                        }
     331                    }
     332                }
     333                else
     334                {
     335                    switch(c)
     336                    {
     337                    case 0x01: //CACA_KEY_CTRL_A:
     338                        command = 1; break;
     339                    case CACA_KEY_UP:
     340                        write(screen_list->screen[screen_list->pty]->fd, "\x1b[A", 3); break;
     341                    case CACA_KEY_DOWN:
     342                        write(screen_list->screen[screen_list->pty]->fd, "\x1b[B", 3); break;
     343                    case CACA_KEY_RIGHT:
     344                        write(screen_list->screen[screen_list->pty]->fd, "\x1b[C", 3); break;
     345                    case CACA_KEY_LEFT:
     346                        write(screen_list->screen[screen_list->pty]->fd, "\x1b[D", 3); break;
     347                    case CACA_KEY_ESCAPE:
     348                        if(screen_list->help)
     349                        {
     350                            screen_list->help = 0;
     351                            refresh = 1;
     352                            break;
     353                        }
     354                    default:
     355                        write(screen_list->screen[screen_list->pty]->fd, &c, 1); break;
     356                    }
    310357                }
    311358            }
     
    344391
    345392        /* Resfresh screen */
    346         if((refresh || screen_list->in_bell) &&
    347            (get_ms() - last_key_time < screen_list->screensaver_timeout))
    348         {
    349             refresh = 0;
    350             refresh_screens(cv, dp, screen_list);
    351         }
    352         if((get_ms() - last_key_time > screen_list->screensaver_timeout))
    353         {
    354             if(!screen_list->in_screensaver)
    355                 screensaver_init(cv, dp, screen_list);
    356             screen_list->in_screensaver = 1;
    357 
    358             caca_set_cursor(dp, 0);
    359             draw_screensaver(cv, dp, screen_list);
     393
     394        if(screen_list->locked)
     395        {
     396            draw_lock(cv, screen_list);
    360397            caca_refresh_display(dp);
    361398        }
     399        else
     400        {
     401
     402            if((refresh || screen_list->in_bell) &&
     403               (get_ms() - last_key_time < screen_list->screensaver_timeout))
     404            {
     405                refresh = 0;
     406                refresh_screens(cv, dp, screen_list);
     407            }
     408
     409            if((get_ms() - last_key_time > screen_list->screensaver_timeout))
     410            {
     411                if(!screen_list->in_screensaver)
     412                    screensaver_init(cv, dp, screen_list);
     413                screen_list->in_screensaver = 1;
     414
     415                caca_set_cursor(dp, 0);
     416                draw_screensaver(cv, dp, screen_list);
     417                caca_refresh_display(dp);
     418            }
     419        }
    362420
    363421        eof = 1;
    364         for(i = 0; i < screen_list->count; i++)
     422        for(i=0; i < screen_list->count; i++)
    365423            if(screen_list->screen[i]->fd >= 0)
    366424                eof = 0;
  • neercs/trunk/src/neercs.h

    r2455 r2457  
    6262    int in_bell;                 /* Bell occuring in a window  */
    6363    int dont_update_coords;      /* Used by recurrents */
     64
     65    /* Lock */
     66    int locked;
     67    char lockpass[1024];
     68    char lockmsg[1024];
     69
    6470    /* Add-ons*/
    6571    int mini;                    /* Thumbnails */
     
    131137void draw_status(cucul_canvas_t *cv, struct screen_list *screen_list);
    132138void draw_help(cucul_canvas_t *cv, struct screen_list *screen_list);
     139void draw_lock(cucul_canvas_t *cv, struct screen_list *screen_list);
     140int validate_lock(struct screen_list *screen_list, char *user, char *pass);
     141
    133142int close_screen_recurrent(struct screen_list*, struct recurrent* rec, void *user, long long unsigned int t);
    134143
Note: See TracChangeset for help on using the changeset viewer.