#define SCALE_FACTOR 31/20
/* LSH_PWD.C
Jason Hunter
8/2/94
DCNS/IS MIT
Re-written for KFW 2.6 by Jeffrey Altman <jaltman@mit.edu>
Contains the callback functions for the EnterPassword an
ChangePassword dialog boxes and well as the API function
calls:
Lsh_Enter_Password_Dialog
Lsh_Change_Password_Dialog
for calling the dialogs.
Also contains the callback for the MITPasswordControl.
*/
/* Standard Include files */
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <string.h>
/* Private Inlclude files */
#include "leashdll.h"
#include <leashwin.h>
#include "leash-int.h"
#include "leashids.h"
#include <leasherr.h>
#include <krb5.h>
#include <commctrl.h>
extern void * Leash_pec_create(HWND hEditCtl);
extern void Leash_pec_destroy(void *pAutoComplete);
extern void Leash_pec_add_principal(char *principal);
extern void Leash_pec_clear_history(void *pec);
/* Global Variables. */
static long lsh_errno;
static char *err_context; /* error context */
extern HINSTANCE hLeashInst;
extern HINSTANCE hKrb5;
INT_PTR
CALLBACK
PasswordProc(
HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);
INT_PTR
CALLBACK
AuthenticateProc(
HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);
INT_PTR
CALLBACK
NewPasswordProc(
HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);
long Leash_get_lsh_errno(LONG *err_val)
{
return lsh_errno;
}
/*/////// ******** API Calls follow here. ******** /////////*/
static int
NetId_dialog(LPLSH_DLGINFO lpdlginfo)
{
LRESULT lrc;
HWND hNetIdMgr;
HWND hForeground;
hNetIdMgr = FindWindow("IDMgrRequestDaemonCls", "IDMgrRequestDaemon");
if (hNetIdMgr != NULL) {
char desiredPrincipal[512];
NETID_DLGINFO *dlginfo;
char *desiredName = 0;
char *desiredRealm = 0;
HANDLE hMap;
DWORD tid = GetCurrentThreadId();
char mapname[256];
strcpy(desiredPrincipal, lpdlginfo->principal);
/* do we want a specific client principal? */
if (desiredPrincipal[0]) {
char * p;
desiredName = desiredPrincipal;
for (p = desiredName; *p && *p != '@'; p++);
if ( *p == '@' ) {
*p = '\0';
desiredRealm = ++p;
}
}
sprintf(mapname,"Local\\NetIDMgr_DlgInfo_%lu",tid);
hMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, 4096, mapname);
if (hMap == NULL) {
return -1;
} else if (hMap != NULL && GetLastError() == ERROR_ALREADY_EXISTS) {
CloseHandle(hMap);
return -1;
}
dlginfo = (NETID_DLGINFO *)MapViewOfFileEx(hMap, FILE_MAP_READ|FILE_MAP_WRITE,
0, 0, 4096, NULL);
if (dlginfo == NULL) {
CloseHandle(hMap);
return -1;
}
hForeground = GetForegroundWindow();
memset(dlginfo, 0, sizeof(NETID_DLGINFO));
dlginfo->size = sizeof(NETID_DLGINFO);
if (lpdlginfo->dlgtype == DLGTYPE_PASSWD)
dlginfo->dlgtype = NETID_DLGTYPE_TGT;
else
dlginfo->dlgtype = NETID_DLGTYPE_CHPASSWD;
dlginfo->in.use_defaults = 1;
if (lpdlginfo->title) {
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
lpdlginfo->title, -1,
dlginfo->in.title, NETID_TITLE_SZ);
} else if (desiredName && (strlen(desiredName) + strlen(desiredRealm) + 32 < NETID_TITLE_SZ)) {
char mytitle[NETID_TITLE_SZ];
sprintf(mytitle, "Obtain Kerberos TGT for %s@%s",desiredName,desiredRealm);
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
mytitle, -1,
dlginfo->in.title, NETID_TITLE_SZ);
} else {
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
"Obtain Kerberos TGT", -1,
dlginfo->in.title, NETID_TITLE_SZ);
}
if (desiredName)
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
desiredName, -1,
dlginfo->in.username, NETID_USERNAME_SZ);
if (desiredRealm)
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
desiredRealm, -1,
dlginfo->in.realm, NETID_REALM_SZ);
lrc = SendMessage(hNetIdMgr, 32810, 0, (LPARAM) tid);
UnmapViewOfFile(dlginfo);
CloseHandle(hMap);
SetForegroundWindow(hForeground);
return lrc;
}
return -1;
}
static int
NetId_dialog_ex(LPLSH_DLGINFO_EX lpdlginfo)
{
HWND hNetIdMgr;
HWND hForeground;
hNetIdMgr = FindWindow("IDMgrRequestDaemonCls", "IDMgrRequestDaemon");
if (hNetIdMgr != NULL) {
NETID_DLGINFO *dlginfo;
char *desiredName = lpdlginfo->username;
char *desiredRealm = lpdlginfo->realm;
LPSTR title;
char *ccache;
LRESULT lrc;
HANDLE hMap;
DWORD tid = GetCurrentThreadId();
char mapname[256];
sprintf(mapname,"Local\\NetIDMgr_DlgInfo_%lu",tid);
hMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, 4096, mapname);
if (hMap == NULL) {
return -1;
} else if (hMap != NULL && GetLastError() == ERROR_ALREADY_EXISTS) {
CloseHandle(hMap);
return -1;
}
dlginfo = (NETID_DLGINFO *)MapViewOfFileEx(hMap, FILE_MAP_READ|FILE_MAP_WRITE,
0, 0, 4096, NULL);
if (dlginfo == NULL) {
CloseHandle(hMap);
return -1;
}
hForeground = GetForegroundWindow();
if (lpdlginfo->size == LSH_DLGINFO_EX_V1_SZ ||
lpdlginfo->size == LSH_DLGINFO_EX_V2_SZ)
{
title = lpdlginfo->title;
desiredName = lpdlginfo->username;
desiredRealm = lpdlginfo->realm;
ccache = NULL;
} else {
title = lpdlginfo->in.title;
desiredName = lpdlginfo->in.username;
desiredRealm = lpdlginfo->in.realm;
ccache = lpdlginfo->in.ccache;
}
memset(dlginfo, 0, sizeof(NETID_DLGINFO));
dlginfo->size = sizeof(NETID_DLGINFO);
if (lpdlginfo->dlgtype == DLGTYPE_PASSWD)
dlginfo->dlgtype = NETID_DLGTYPE_TGT;
else
dlginfo->dlgtype = NETID_DLGTYPE_CHPASSWD;
dlginfo->in.use_defaults = lpdlginfo->use_defaults;
dlginfo->in.forwardable = lpdlginfo->forwardable;
dlginfo->in.noaddresses = lpdlginfo->noaddresses;
dlginfo->in.lifetime = lpdlginfo->lifetime;
dlginfo->in.renew_till = lpdlginfo->renew_till;
dlginfo->in.proxiable = lpdlginfo->proxiable;
dlginfo->in.publicip = lpdlginfo->publicip;
if (title) {
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
title, -1,
dlginfo->in.title, NETID_TITLE_SZ);
} else if (desiredName && (strlen(desiredName) + strlen(desiredRealm) + 32 < NETID_TITLE_SZ)) {
char mytitle[NETID_TITLE_SZ];
sprintf(mytitle, "Obtain Kerberos TGT for %s@%s",desiredName,desiredRealm);
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
mytitle, -1,
dlginfo->in.title, NETID_TITLE_SZ);
} else {
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
"Obtain Kerberos TGT", -1,
dlginfo->in.title, NETID_TITLE_SZ);
}
if (desiredName)
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
desiredName, -1,
dlginfo->in.username, NETID_USERNAME_SZ);
if (desiredRealm)
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
desiredRealm, -1,
dlginfo->in.realm, NETID_REALM_SZ);
if (ccache)
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
ccache, -1,
dlginfo->in.ccache, NETID_CCACHE_NAME_SZ);
lrc = SendMessage(hNetIdMgr, 32810, 0, (LPARAM) tid);
if (lrc > 0) {
if (lpdlginfo->size == LSH_DLGINFO_EX_V2_SZ)
{
WideCharToMultiByte(CP_ACP, 0, dlginfo->out.username, -1,
lpdlginfo->out.username, LEASH_USERNAME_SZ,
NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, dlginfo->out.realm, -1,
lpdlginfo->out.realm, LEASH_REALM_SZ,
NULL, NULL);
}
if (lpdlginfo->size == LSH_DLGINFO_EX_V3_SZ)
{
WideCharToMultiByte(CP_ACP, 0, dlginfo->out.ccache, -1,
lpdlginfo->out.ccache, LEASH_CCACHE_NAME_SZ,
NULL, NULL);
}
}
UnmapViewOfFile(dlginfo);
CloseHandle(hMap);
SetForegroundWindow(hForeground);
return lrc;
}
return -1;
}
#define LEASH_DLG_MUTEX_NAME TEXT("Leash_Dialog_Mutex")
int Leash_kinit_dlg(HWND hParent, LPLSH_DLGINFO lpdlginfo)
{
int rc;
HANDLE hMutex;
rc = NetId_dialog(lpdlginfo);
if (rc > -1)
return rc;
hMutex = CreateMutex(NULL, TRUE, LEASH_DLG_MUTEX_NAME);
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
if ( WaitForSingleObject( hMutex, INFINITE ) != WAIT_OBJECT_0 ) {
return -1;
}
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return 1; /* pretend the dialog was displayed and succeeded */
}
lpdlginfo->dlgtype = DLGTYPE_PASSWD;
/* set the help file */
Leash_set_help_file(NULL);
/* Call the Dialog box with the DLL's Password Callback and the
DLL's instance handle. */
rc = DialogBoxParam(hLeashInst, "EnterPasswordDlg", hParent,
PasswordProc, (LPARAM)lpdlginfo);
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return rc;
}
int Leash_kinit_dlg_ex(HWND hParent, LPLSH_DLGINFO_EX lpdlginfo)
{
int rc;
HANDLE hMutex;
rc = NetId_dialog_ex(lpdlginfo);
if (rc > -1)
return rc;
hMutex = CreateMutex(NULL, TRUE, LEASH_DLG_MUTEX_NAME);
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
if ( WaitForSingleObject( hMutex, INFINITE ) != WAIT_OBJECT_0 ) {
return -1;
}
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return 1; /* pretend the dialog was displayed and succeeded */
}
/* set the help file */
Leash_set_help_file(NULL);
/* Call the Dialog box with the DLL's Password Callback and the
DLL's instance handle. */
rc = DialogBoxParam(hLeashInst, MAKEINTRESOURCE(IDD_AUTHENTICATE), hParent,
AuthenticateProc, (LPARAM)lpdlginfo);
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return rc;
}
int Leash_changepwd_dlg(HWND hParent, LPLSH_DLGINFO lpdlginfo)
{
int rc;
HANDLE hMutex;
rc = NetId_dialog(lpdlginfo);
if (rc > -1)
return rc;
hMutex = CreateMutex(NULL, TRUE, LEASH_DLG_MUTEX_NAME);
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
if ( WaitForSingleObject( hMutex, INFINITE ) != WAIT_OBJECT_0 ) {
return -1;
}
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return 1; /* pretend the dialog was displayed and succeeded */
}
lpdlginfo->dlgtype = DLGTYPE_CHPASSWD;
/* Call the Dialog box with the DLL's Password Callback and the
DLL's instance handle. */
rc = DialogBoxParam(hLeashInst, "CHANGEPASSWORDDLG", hParent,
PasswordProc, (LPARAM)lpdlginfo);
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return rc;
}
int Leash_changepwd_dlg_ex(HWND hParent, LPLSH_DLGINFO_EX lpdlginfo)
{
int rc;
HANDLE hMutex;
rc = NetId_dialog_ex(lpdlginfo);
if (rc > -1)
return rc;
hMutex = CreateMutex(NULL, TRUE, LEASH_DLG_MUTEX_NAME);
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
if ( WaitForSingleObject( hMutex, INFINITE ) != WAIT_OBJECT_0 ) {
return -1;
}
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return 1; /* pretend the dialog was displayed and succeeded */
}
lpdlginfo->dlgtype = DLGTYPE_CHPASSWD;
/* Call the Dialog box with the DLL's Password Callback and the
DLL's instance handle. */
rc = DialogBoxParam(hLeashInst, MAKEINTRESOURCE(IDD_PASSWORD), hParent,
NewPasswordProc, (LPARAM)lpdlginfo);
ReleaseMutex(hMutex);
CloseHandle(hMutex);
return rc;
}
/* These little utils are taken from lshutil.c
they are added here for the Call back funtion.
****** beginning of added utils from lshutil.c ******/
BOOL IsDlgItem(HWND hWnd, WORD id)
{
HWND hChild;
hChild = GetDlgItem(hWnd, id);
return hChild ? IsWindow(hChild) : 0;
}
int lsh_getkeystate(WORD keyid)
{
static BYTE keys[256];
GetKeyboardState((LPBYTE) &keys);
return (int) keys[keyid];
}
LPSTR krb_err_func(int offset, long code)
{
return(NULL);
}
/****** End of Added utils from leash.c ******/
int PaintLogoBitmap( HANDLE hPicFrame )
{
HBITMAP hBitmap;
HBITMAP hOldBitmap;
BITMAP Bitmap;
HDC hdc, hdcMem;
RECT rect;
/* Invalidate the drawing space of the picframe. */
InvalidateRect( hPicFrame, NULL, TRUE);
UpdateWindow( hPicFrame );
hdc = GetDC(hPicFrame);
hdcMem = CreateCompatibleDC(hdc);
GetClientRect(hPicFrame, &rect);
hBitmap = LoadBitmap(hLeashInst, "LOGOBITMAP");
hOldBitmap = SelectObject(hdcMem, hBitmap);
GetObject(hBitmap, sizeof(Bitmap), (LPSTR) &Bitmap);
StretchBlt(hdc, 0, 0, rect.right, rect.bottom, hdcMem, 0, 0,
Bitmap.bmWidth, Bitmap.bmHeight, SRCCOPY);
SelectObject(hdcMem, hOldBitmap); /* pbh 8-15-94 */
ReleaseDC(hPicFrame, hdc);
DeleteObject( hBitmap ); /* pbh 8-15-94 */
DeleteDC( hdcMem ); /* pbh 8-15-94 */
return 0;
}
/* Callback function for the Password Dialog box that initilializes and
renews tickets. */
INT_PTR
CALLBACK
PasswordProc(
HWND hDialog,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
static POINT Position = { -1, -1 };
static short state;
int lifetime;
#define ISCHPASSWD (lpdi->dlgtype == DLGTYPE_CHPASSWD)
#define STATE_INIT 0
#define STATE_PRINCIPAL 1
#define STATE_OLDPWD 2
#define STATE_NEWPWD1 3
#define STATE_NEWPWD2 4
#define STATE_CLOSED 5
#define NEXTSTATE(newstate) SendMessage(hDialog, WM_COMMAND, ID_NEXTSTATE, newstate)
static int ids[STATE_NEWPWD2 + 1] = {
0,
ID_PRINCIPAL, ID_OLDPASSWORD, ID_CONFIRMPASSWORD1,
ID_CONFIRMPASSWORD2};
static char principal[255], oldpassword[255], newpassword[255],
newpassword2[255];
static char *strings[STATE_NEWPWD2 + 1] = {
NULL, principal, oldpassword, newpassword, newpassword2};
static LPLSH_DLGINFO lpdi;
char gbuf[200]; /* global buffer for random stuff. */
#define checkfirst(id, stuff) IsDlgItem(hDialog, id) ? stuff : 0
#define CGetDlgItemText(hDlg, id, cp, len) checkfirst(id, GetDlgItemText(hDlg, id, cp, len))
#define CSetDlgItemText(hDlg, id, cp) checkfirst(id, SetDlgItemText(hDlg, id, cp))
#define CSetDlgItemInt(hDlg, id, i, b) checkfirst(id, SetDlgItemInt(hDlg, id, i, b))
#define CSendDlgItemMessage(hDlg, id, m, w, l) checkfirst(id, SendDlgItemMessage(hDlg, id, m, w, l))
#define CSendMessage(hwnd, m, w, l) IsWindow(hwnd) ? SendMessage(hwnd, m, w, l) : 0
#define CShowWindow(hwnd, state) IsWindow(hwnd) ? ShowWindow(hwnd, state) : 0
#define GETITEMTEXT(id, cp, maxlen) \
GetDlgItemText(hDialog, id, (LPSTR)(cp), maxlen)
#define CloseMe(x) SendMessage(hDialog, WM_COMMAND, ID_CLOSEME, x)
#define EDITFRAMEIDOFFSET 500
switch (message) {
case WM_INITDIALOG:
*( (LPLSH_DLGINFO far *)(&lpdi) ) = (LPLSH_DLGINFO)(LPSTR)lParam;
lpdi->dlgstatemax = ISCHPASSWD ? STATE_NEWPWD2
: STATE_OLDPWD;
SetWindowText(hDialog, lpdi->title);
/* stop at old password for normal password dlg */
SetProp(hDialog, "HANDLES_HELP", (HANDLE)1);
if (lpdi->principal)
lstrcpy(principal, lpdi->principal);
else
{
principal[0] = '\0';
/* is there a principal already being used? if so, use it. */
}
CSetDlgItemText(hDialog, ID_PRINCIPAL, principal);
lifetime = Leash_get_default_lifetime();
if (lifetime <= 0)
lifetime = 600; /* 10 hours */
CSetDlgItemInt(hDialog, ID_DURATION, lifetime, FALSE);
/* setup text of stuff. */
if (Position.x > 0 && Position.y > 0 &&
Position.x < GetSystemMetrics(SM_CXSCREEN) &&
Position.y < GetSystemMetrics(SM_CYSCREEN))
SetWindowPos(hDialog, 0, Position.x, Position.y, 0, 0,
SWP_NOSIZE | SWP_NOZORDER);
/* set window pos to last saved window pos */
/* replace standard edit control with our own password edit
control for password entry. */
{
RECT r;
POINT pxy, psz;
HWND hwnd;
int i;
for (i = ID_OLDPASSWORD; i <= ids[lpdi->dlgstatemax]; i++)
{
hwnd = GetDlgItem(hDialog, i);
GetWindowRect(hwnd, &r);
psz.x = r.right - r.left;
psz.y = r.bottom - r.top;
pxy.x = r.left; pxy.y = r.top;
ScreenToClient(hDialog, &pxy);
/* create a substitute window: */
DestroyWindow(hwnd);
/* kill off old edit window. */
CreateWindow(MIT_PWD_DLL_CLASS, /* our password window :o] */
"", /* no text */
WS_CHILD | WS_VISIBLE | WS_TABSTOP, /* child window, visible,tabstop */
pxy.x, pxy.y, /* x, y coords */
psz.x, psz.y, /* width, height */
hDialog, /* the parent */
(HMENU)i, /* same id *//* id offset for the frames */
(HANDLE)hLeashInst,/* instance handles */
NULL); /* createstruct */
}
}
state = STATE_INIT;
NEXTSTATE(STATE_PRINCIPAL);
break;
case WM_PAINT:
PaintLogoBitmap( GetDlgItem(hDialog, ID_PICFRAME) );
break;
case WM_COMMAND:
switch (wParam) {
case ID_HELP:
{
WinHelp(GetWindow(hDialog,GW_OWNER), KRB_HelpFile, HELP_CONTEXT,
ISCHPASSWD ? ID_CHANGEPASSWORD : ID_INITTICKETS);
}
break;
case ID_CLOSEME:
{
int i;
for (i = STATE_PRINCIPAL; i <= lpdi->dlgstatemax; i++)
{
memset(strings[i], '\0', 255);
SetDlgItemText(hDialog, ids[i], "");
}
/* I claim these passwords in the name
of planet '\0'... */
RemoveProp(hDialog, "HANDLES_HELP");
state = STATE_CLOSED;
EndDialog(hDialog, (int)lParam);
return TRUE;
}
break;
case ID_DURATION:
break;
case ID_PRINCIPAL:
case ID_OLDPASSWORD:
case ID_CONFIRMPASSWORD1:
case ID_CONFIRMPASSWORD2:
if (HIWORD(lParam) == EN_SETFOCUS)
{
/* nothing, for now. */
}
break;
case ID_NEXTSTATE:
{
RECT rbtn, redit;
POINT p;
int idfocus, i, s;
HWND hfocus, hbtn;
int oldstate = state;
state = (int)lParam;
idfocus = ids[state];
#ifdef ONE_NEWPWDBOX
if (state == STATE_NEWPWD2)
SendDlgItemMessage(hDialog, ID_CONFIRMPASSWORD1, WM_SETTEXT,
0, (LONG)(LPSTR)"");
#endif
for (s = STATE_PRINCIPAL; s <= lpdi->dlgstatemax; s++)
{
i = ids[s];
if (s > state)
SendDlgItemMessage(hDialog, i, WM_SETTEXT, 0,
(LONG)(LPSTR)"");
EnableWindow(GetDlgItem(hDialog, i), i == idfocus);
ShowWindow(GetDlgItem(hDialog, i),
(i <= idfocus ? SW_SHOW : SW_HIDE));
/* ShowWindow(GetDlgItem(hDialog, i + CAPTION_OFFSET),
(i <= idfocus ? SW_SHOW : SW_HIDE));*/
/* show caption? */
}
#ifdef ONE_NEWPWDBOX
CSetDlgItemText(hDialog, ID_CONFIRMCAPTION1,
state < STATE_NEWPWD2 ?
"Enter new password:" :
"Enter new password again:");
if (state == STATE_NEWPWD2)
{
HWND htext;
htext = GetDlgItem(hDialog, ID_CONFIRMCAPTION1);
FlashAnyWindow(htext);
WinSleep(50);
FlashAnyWindow(htext);
}
#endif
hfocus = GetDlgItem(hDialog, idfocus);
if ( hfocus != (HWND)NULL ){
SetFocus(hfocus); /* switch focus */
if (idfocus >= ID_OLDPASSWORD)
SendMessage(hfocus, WM_SETTEXT, 0, (LPARAM) (LPSTR) "");
else
{
SendMessage(hfocus, EM_SETSEL, 0, MAKELONG(0, -1));
}
GetWindowRect(hfocus, &redit);
}
hbtn = GetDlgItem(hDialog, IDOK);
if( IsWindow(hbtn) ){
GetWindowRect(hbtn, &rbtn);
p.x = rbtn.left; p.y = redit.top;
ScreenToClient(hDialog, &p);
SetWindowPos(hbtn, 0, p.x, p.y, 0, 0,
SWP_NOSIZE | SWP_NOZORDER);
}
}
break;
case IDOK:
{
char* p_Principal;
DWORD value = 0;
GETITEMTEXT(ids[state], (LPSTR)strings[state], 255);
switch(state)
{
case STATE_PRINCIPAL:
{
if (!principal[0])
{
MessageBox(hDialog,
"You are not allowed to enter a blank principal.",
"Invalid Principal",
MB_OK | MB_ICONSTOP);
NEXTSTATE(STATE_PRINCIPAL);
return TRUE;
}
// Change 'principal' to upper case after checking
// "UpperCase" value in the Registry
p_Principal = strchr(principal, '@');
if (p_Principal && Leash_get_default_uppercaserealm())
strupr(p_Principal);
break;
}
case STATE_OLDPWD:
{
int duration;
if (!ISCHPASSWD)
duration = GetDlgItemInt(hDialog, ID_DURATION, 0, FALSE);
if (!oldpassword[0])
{
MessageBox(hDialog, "You are not allowed to enter a "
"blank password.",
"Invalid Password",
MB_OK | MB_ICONSTOP);
NEXTSTATE(STATE_OLDPWD);
return TRUE;
}
if (lpdi->dlgtype == DLGTYPE_CHPASSWD)
lsh_errno = Leash_int_checkpwd(principal, oldpassword, 1);
else
{
lsh_errno = Leash_int_kinit_ex( 0,
hDialog,
principal,
oldpassword,
duration,
Leash_get_default_forwardable(),
Leash_get_default_proxiable(),
Leash_get_default_renew_till(),
Leash_get_default_noaddresses(),
Leash_get_default_publicip(),
1
);
}
if (lsh_errno != 0)
{
int next_state = state;
int capslock;
char *cp;
err_context = "";
switch(lsh_errno)
{
case LSH_INVPRINCIPAL:
case LSH_INVINSTANCE:
case LSH_INVREALM:
next_state = STATE_PRINCIPAL;
break;
}
capslock = lsh_getkeystate(VK_CAPITAL);
/* low-order bit means caps lock is
toggled; if so, warn user since there's
been an error. */
if (capslock & 1)
{
lstrcpy((LPSTR)gbuf, (LPSTR)err_context);
cp = gbuf + lstrlen((LPSTR)gbuf);
if (cp != gbuf)
*cp++ = ' ';
lstrcpy(cp, "(This may be because your CAPS LOCK key is down.)");
err_context = gbuf;
}
// XXX DoNiftyErrorReport(lsh_errno, ISCHPASSWD ? ""
// XXX : "Ticket initialization failed.");
NEXTSTATE(next_state);
return TRUE;
}
if (ISCHPASSWD)
break;
CloseMe(TRUE); /* success */
}
break;
case STATE_NEWPWD1:
{
int i = 0;
int bit8 = 0;
for( i = 0; i < 255; i++ ){
if( newpassword[i] == '\0' ){
if ( bit8 ) {
MessageBox(hDialog,
"Passwords should not contain non-ASCII characters.",
"Internationalization Warning",
MB_OK | MB_ICONINFORMATION);
}
i = 255;
break;
} else if( !isprint(newpassword[i]) ){
memset(newpassword, '\0', 255);
/* I claim these passwords in the name of planet '\0'... */
MessageBox(hDialog,
"Passwords may not contain non-printable characters.",
"Invalid Password",
MB_OK | MB_ICONSTOP);
NEXTSTATE(STATE_NEWPWD1);
return TRUE;
} else if ( newpassword[i] > 127 )
bit8 = 1;
}
}
break;
case STATE_NEWPWD2:
if (lstrcmp(newpassword, newpassword2))
{
NEXTSTATE(STATE_NEWPWD1);
MessageBox(hDialog,
"The new password was not entered the same way twice.",
"Password validation error",
MB_OK | MB_ICONSTOP);
return TRUE;
}
else
{
/* make them type both pwds again if error */
int next_state = STATE_NEWPWD1;
int capslock;
char *cp;
capslock = lsh_getkeystate(VK_CAPITAL);
/* low-order bit means caps lock is
toggled; if so, warn user since there's
been an error. */
if (capslock & 1)
{
lstrcpy((LPSTR)gbuf, (LPSTR)err_context);
cp = gbuf + lstrlen((LPSTR)gbuf);
if (cp != gbuf)
*cp++ = ' ';
lstrcpy(cp, "(This may be because your CAPS LOCK key is down.)");
err_context = gbuf;
}
if ((lsh_errno =
Leash_int_changepwd(principal, oldpassword,
newpassword, 0, 1))
== 0){
CloseMe(TRUE);
}
else {
// XXX - DoNiftyErrorReport(lsh_errno, "Error while changing password.");
NEXTSTATE(next_state);
return TRUE;
}
}
break;
}
/* increment state, but send the old state as a
parameter */
SendMessage(hDialog, WM_COMMAND, ID_NEXTSTATE, state + 1);
}
break;
case IDCANCEL:
CloseMe(FALSE);
break;
case ID_RESTART:
{
int i;
for (i = ID_OLDPASSWORD; i <= ids[lpdi->dlgstatemax]; i++)
SetDlgItemText(hDialog, i, "");
SendMessage(hDialog, WM_COMMAND, ID_NEXTSTATE,
STATE_PRINCIPAL);
}
break;
}
break;
case WM_MOVE:
if (state != STATE_CLOSED)
#ifdef _WIN32
#define LONG2POINT(l,pt) ((pt).x=(SHORT)LOWORD(l), \
(pt).y=(SHORT)HIWORD(l))
LONG2POINT(lParam,Position);
#else
Position = MAKEPOINT(lParam);
#endif
break;
}
return FALSE;
}
#define KRB_FILE "KRB.CON"
#define KRBREALM_FILE "KRBREALM.CON"
#define KRB5_FILE "KRB5.INI"
BOOL
GetProfileFile(
LPSTR confname,
UINT szConfname
)
{
char **configFile = NULL;
if (hKrb5 &&
pkrb5_get_default_config_files(&configFile))
{
GetWindowsDirectory(confname,szConfname);
confname[szConfname-1] = '\0';
strncat(confname, "\\",sizeof(confname)-strlen(confname));
confname[szConfname-1] = '\0';
strncat(confname, KRB5_FILE,sizeof(confname)-strlen(confname));
confname[szConfname-1] = '\0';
return FALSE;
}
*confname = 0;
if (hKrb5 && configFile)
{
strncpy(confname, *configFile, szConfname);
pkrb5_free_config_files(configFile);
}
if (!*confname)
{
GetWindowsDirectory(confname,szConfname);
confname[szConfname-1] = '\0';
strncat(confname, "\\",sizeof(confname)-strlen(confname));
confname[szConfname-1] = '\0';
strncat(confname, KRB5_FILE,sizeof(confname)-strlen(confname));
confname[szConfname-1] = '\0';
}
return FALSE;
}
int
readstring(FILE * file, char * buf, int len)
{
int c,i;
memset(buf, '\0', sizeof(buf));
for (i=0, c=fgetc(file); c != EOF ; c=fgetc(file), i++)
{
if (i < sizeof(buf)) {
if (c == '\n') {
buf[i] = '\0';
return i;
} else {
buf[i] = c;
}
} else {
if (c == '\n') {
buf[len-1] = '\0';
return(i);
}
}
}
if (c == EOF) {
if (i > 0 && i < len) {
buf[i] = '\0';
return(i);
} else {
buf[len-1] = '\0';
return(-1);
}
}
return(-1);
}
typedef struct _slider_info {
int slider_id;
int text_id;
int min;
int max;
int increment;
struct _slider_info * next;
} slider_info;
static slider_info * sliders = NULL;
static slider_info *
FreeSlider(slider_info * s)
{
slider_info * n = NULL;
if (s) {
n = s->next;
free(s);
}
return n;
}
static void
CleanupSliders(void)
{
while(sliders)
sliders = FreeSlider(sliders);
}
static unsigned short
NewSliderValue(HWND hDialog, int id)
{
int value = 0;
slider_info * s = sliders;
while(s) {
if (s->slider_id == id) {
int pos = CSendDlgItemMessage( hDialog, id,
TBM_GETPOS,
(WPARAM) 0, (LPARAM) 0);
value = s->min + (pos * s->increment);
break;
}
s = s->next;
}
return(value);
}
static const char *
NewSliderString(int id, int pos)
{
static char buf[64]="";
char * p = buf;
int value = 0;
int must_hours = 0;
slider_info * s = sliders;
while(s) {
if (s->slider_id == id) {
value = s->min + pos * s->increment;
*p = 0;
if (value >= 60 * 24) {
sprintf(p,"%d day(s) ",value / (60 * 24));
value %= (60 * 24);
p += strlen(p);
must_hours = 1;
}
if (must_hours || value >= 60) {
sprintf(p,"%d hour(s) ",value / 60);
value %= 60;
p += strlen(p);
}
sprintf(p,"%d minute(s) ",value);
break;
}
s = s->next;
}
return(buf);
}
static void
SetupSlider( HWND hDialog,
int sliderID,
int textFieldID,
int minimum,
int maximum,
int value)
{
int min = minimum;
int max = maximum;
int increment = 0;
int range;
int roundedMinimum;
int roundedMaximum;
int roundedValue;
slider_info * new_info;
if (max < min) {
// swap values
int temp = max;
max = min;
min = temp;
}
range = max - min;
if (range < 5*60) { increment = 1; // 1 s if under 5 m
} else if (range < 30*60) { increment = 5; // 5 s if under 30 m
} else if (range < 60*60) { increment = 15; // 15 s if under 1 h
} else if (range < 2*60*60) { increment = 30; // 30 s if under 2 h
} else if (range < 5*60*60) { increment = 60; // 1 m if under 5 h
} else if (range < 50*60*60) { increment = 5*60; // 5 m if under 50 h
} else if (range < 200*60*60) { increment = 15*60; // 15 m if under 200 h
} else if (range < 500*60*60) { increment = 30*60; // 30 m if under 500 h
} else { increment = 60*60; } // 1 h otherwise
roundedMinimum = (min / increment) * increment;
if (roundedMinimum > min) { roundedMinimum -= increment; }
if (roundedMinimum <= 0) { roundedMinimum += increment; } // make positive
roundedMaximum = (max / increment) * increment;
if (roundedMaximum < max) { roundedMaximum += increment; }
roundedValue = (value / increment) * increment;
if (roundedValue < roundedMinimum) { roundedValue = roundedMinimum; }
if (roundedValue > roundedMaximum) { roundedValue = roundedMaximum; }
if (roundedMinimum == roundedMaximum) {
// [textField setTextColor: [NSColor grayColor]];
EnableWindow(GetDlgItem(hDialog,sliderID),FALSE);
} else {
// [textField setTextColor: [NSColor blackColor]];
EnableWindow(GetDlgItem(hDialog,sliderID),TRUE);
}
CSendDlgItemMessage( hDialog, sliderID,
TBM_SETRANGEMIN,
(WPARAM) FALSE,
(LPARAM) 0 );
CSendDlgItemMessage( hDialog, sliderID,
TBM_SETRANGEMAX,
(WPARAM) FALSE,
(LPARAM) (roundedMaximum - roundedMinimum) / increment );
CSendDlgItemMessage( hDialog, sliderID,
TBM_SETPOS,
(WPARAM) TRUE,
(LPARAM) (roundedValue - roundedMinimum) / increment);
new_info = (slider_info *) malloc(sizeof(slider_info));
new_info->slider_id = sliderID;
new_info->text_id = textFieldID;
new_info->min = roundedMinimum;
new_info->max = roundedMaximum;
new_info->increment = increment;
new_info->next = sliders;
sliders = new_info;
SetWindowText(GetDlgItem(hDialog, textFieldID),
NewSliderString(sliderID,(roundedValue - roundedMinimum) / increment));
}
static void
AdjustOptions(HWND hDialog, int show, int hideDiff)
{
RECT rect;
RECT dlgRect;
HWND hwnd;
int diff;
Leash_set_hide_kinit_options(!show);
ShowWindow(GetDlgItem(hDialog,IDC_STATIC_LIFETIME),show);
ShowWindow(GetDlgItem(hDialog,IDC_STATIC_LIFETIME_VALUE),show);
ShowWindow(GetDlgItem(hDialog,IDC_SLIDER_LIFETIME),show);
ShowWindow(GetDlgItem(hDialog,IDC_SLIDER_RENEWLIFE),show);
ShowWindow(GetDlgItem(hDialog,IDC_STATIC_RENEW),show);
ShowWindow(GetDlgItem(hDialog,IDC_STATIC_RENEW_TILL_VALUE),show);
ShowWindow(GetDlgItem(hDialog,IDC_CHECK_FORWARDABLE),show);
ShowWindow(GetDlgItem(hDialog,IDC_CHECK_NOADDRESS),show);
ShowWindow(GetDlgItem(hDialog,IDC_CHECK_RENEWABLE),show);
ShowWindow(GetDlgItem(hDialog,IDC_STATIC_KRB5),show);
ShowWindow(GetDlgItem(hDialog,IDC_BUTTON_CLEAR_HISTORY),show);
GetWindowRect( hDialog, &dlgRect );
diff = dlgRect.top + GetSystemMetrics(SM_CYCAPTION)
+ GetSystemMetrics(SM_CYDLGFRAME) + (show ? -1 : 1) * hideDiff;
hwnd = GetDlgItem(hDialog,IDOK);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd,0,rect.left-dlgRect.left-GetSystemMetrics(SM_CXDLGFRAME),rect.top-diff,0,0,SWP_NOZORDER|SWP_NOSIZE);
hwnd = GetDlgItem(hDialog,IDCANCEL);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd,0,rect.left-dlgRect.left-GetSystemMetrics(SM_CXDLGFRAME),rect.top-diff,0,0,SWP_NOZORDER|SWP_NOSIZE);
hwnd = GetDlgItem(hDialog,IDC_BUTTON_OPTIONS);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd,0,rect.left-dlgRect.left-GetSystemMetrics(SM_CXDLGFRAME),rect.top-diff,0,0,SWP_NOZORDER|SWP_NOSIZE);
hwnd = GetDlgItem(hDialog,IDC_STATIC_VERSION);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd,0,rect.left-dlgRect.left-GetSystemMetrics(SM_CXDLGFRAME),rect.top-diff,0,0,SWP_NOZORDER|SWP_NOSIZE);
hwnd = GetDlgItem(hDialog,IDC_STATIC_COPYRIGHT);
GetWindowRect(hwnd,&rect);
SetWindowPos(hwnd,0,rect.left-dlgRect.left-GetSystemMetrics(SM_CXDLGFRAME),rect.top-diff,0,0,SWP_NOZORDER|SWP_NOSIZE);
SetWindowPos(hDialog,0,0,0,
dlgRect.right-dlgRect.left,
dlgRect.bottom-dlgRect.top+(show ? 1 : - 1) * hideDiff,
SWP_NOZORDER|SWP_NOMOVE);
CSetDlgItemText(hDialog, IDC_BUTTON_OPTIONS,
show ? "Hide Advanced" : "Show Advanced");
}
/* Callback function for the Authentication Dialog box that initializes and
renews tickets. */
INT_PTR
CALLBACK
AuthenticateProc(
HWND hDialog,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
static POINT Position = { -1, -1 };
static char principal[256]="";
static char password[256]="";
static int lifetime=0;
static int renew_till=0;
static int forwardable=0;
static int noaddresses=0;
static int proxiable=0;
static int publicip=0;
static LPLSH_DLGINFO_EX lpdi;
static HWND hDlg=0;
static HWND hSliderLifetime=0;
static HWND hSliderRenew=0;
static RECT dlgRect;
static int hideDiff = 0;
static void *pAutoComplete = 0;
long realm_count = 0;
int disable_noaddresses = 0;
HWND hEditCtrl=0;
HWND hFocusCtrl=0;
BOOL bReadOnlyPrinc=0;
switch (message) {
case WM_INITDIALOG:
hDlg = hDialog;
hEditCtrl = GetDlgItem(hDialog, IDC_EDIT_PRINCIPAL);
if (hEditCtrl)
pAutoComplete = Leash_pec_create(hEditCtrl);
hSliderLifetime = GetDlgItem(hDialog, IDC_STATIC_LIFETIME_VALUE);
hSliderRenew = GetDlgItem(hDialog, IDC_STATIC_RENEW_TILL_VALUE);
*( (LPLSH_DLGINFO_EX far *)(&lpdi) ) = (LPLSH_DLGINFO_EX)(LPSTR)lParam;
if ((lpdi->size != LSH_DLGINFO_EX_V1_SZ &&
lpdi->size != LSH_DLGINFO_EX_V2_SZ &&
lpdi->size < LSH_DLGINFO_EX_V3_SZ) ||
(lpdi->dlgtype & DLGTYPE_MASK) != DLGTYPE_PASSWD) {
MessageBox(hDialog, "An incorrect initialization data structure was provided.",
"AuthenticateProc()",
MB_OK | MB_ICONSTOP);
return FALSE;
}
bReadOnlyPrinc = (lpdi->dlgtype & DLGFLAG_READONLYPRINC) ?
TRUE : FALSE;
if ( lpdi->size >= LSH_DLGINFO_EX_V2_SZ ) {
lpdi->out.username[0] = 0;
lpdi->out.realm[0] = 0;
}
if ( lpdi->size >= LSH_DLGINFO_EX_V3_SZ ) {
lpdi->out.ccache[0] = 0;
}
if ( lpdi->size >= LSH_DLGINFO_EX_V3_SZ )
SetWindowText(hDialog, lpdi->in.title);
else
SetWindowText(hDialog, lpdi->title);
SetProp(hDialog, "HANDLES_HELP", (HANDLE)1);
if (lpdi->use_defaults) {
lifetime = Leash_get_default_lifetime();
if (lifetime <= 0)
lifetime = 600; /* 10 hours */
if (Leash_get_default_renewable()) {
renew_till = Leash_get_default_renew_till();
if (renew_till < 0)
renew_till = 10800; /* 7 days */
} else
renew_till = 0;
forwardable = Leash_get_default_forwardable();
if (forwardable < 0)
forwardable = 0;
noaddresses = Leash_get_default_noaddresses();
if (noaddresses < 0)
noaddresses = 0;
proxiable = Leash_get_default_proxiable();
if (proxiable < 0)
proxiable = 0;
publicip = Leash_get_default_publicip();
if (publicip < 0)
publicip = 0;
} else {
forwardable = lpdi->forwardable;
noaddresses = lpdi->noaddresses;
lifetime = lpdi->lifetime;
renew_till = lpdi->renew_till;
proxiable = lpdi->proxiable;
publicip = lpdi->publicip;
}
if (lpdi->username && (strlen(lpdi->username) > 0) &&
lpdi->realm && (strlen(lpdi->realm) > 0)) {
sprintf_s(principal, sizeof(principal), "%s@%s", lpdi->username,
lpdi->realm);
} else {
principal[0] = 0;
}
Edit_SetReadOnly(hEditCtrl, bReadOnlyPrinc);
CSetDlgItemText(hDialog, IDC_EDIT_PRINCIPAL, principal);
CSetDlgItemText(hDialog, IDC_EDIT_PASSWORD, "");
/* Set Lifetime Slider
* min value = 5
* max value = 1440
* current value
*/
SetupSlider( hDialog,
IDC_SLIDER_LIFETIME,
IDC_STATIC_LIFETIME_VALUE,
Leash_get_default_life_min(),
Leash_get_default_life_max(),
lifetime );
CheckDlgButton(hDialog, IDC_CHECK_REMEMBER_PRINCIPAL, TRUE);
/* Set Forwardable checkbox */
CheckDlgButton(hDialog, IDC_CHECK_FORWARDABLE, forwardable);
/* Set NoAddress checkbox */
CheckDlgButton(hDialog, IDC_CHECK_NOADDRESS, noaddresses);
if ( disable_noaddresses )
EnableWindow(GetDlgItem(hDialog,IDC_CHECK_NOADDRESS),FALSE);
/* Set Renewable checkbox */
CheckDlgButton(hDialog, IDC_CHECK_RENEWABLE, renew_till);
/* if not renewable, disable Renew Till slider */
/* if renewable, set Renew Till slider
* min value
* max value
* current value
*/
SetupSlider( hDialog,
IDC_SLIDER_RENEWLIFE,
IDC_STATIC_RENEW_TILL_VALUE,
Leash_get_default_renew_min(),
Leash_get_default_renew_max(),
renew_till);
if (renew_till) {
EnableWindow(GetDlgItem(hDialog,IDC_SLIDER_RENEWLIFE),TRUE);
} else {
EnableWindow(GetDlgItem(hDialog,IDC_SLIDER_RENEWLIFE),FALSE);
}
// Compute sizes of items necessary to show/hide the advanced options
GetWindowRect( hDialog, &dlgRect );
{
RECT okRect, staticRect;
GetWindowRect(GetDlgItem(hDialog,IDC_STATIC_LIFETIME),&staticRect);
GetWindowRect(GetDlgItem(hDialog,IDOK),&okRect);
hideDiff = okRect.top - staticRect.top;
}
if ( hKrb5 ) {
if (Leash_get_hide_kinit_options())
AdjustOptions(hDialog,0,hideDiff);
} else {
AdjustOptions(hDialog,0,hideDiff);
EnableWindow(GetDlgItem(hDialog,IDC_BUTTON_OPTIONS),FALSE);
ShowWindow(GetDlgItem(hDialog,IDC_BUTTON_OPTIONS),SW_HIDE);
}
/* setup text of stuff. */
if (Position.x > 0 && Position.y > 0 &&
Position.x < GetSystemMetrics(SM_CXSCREEN) &&
Position.y < GetSystemMetrics(SM_CYSCREEN))
SetWindowPos(hDialog, HWND_TOP, Position.x, Position.y, 0, 0, SWP_NOSIZE);
else /* Center the window on the desktop */
SetWindowPos(hDialog, HWND_TOP,
(GetSystemMetrics(SM_CXSCREEN) - dlgRect.right + dlgRect.left)/2,
(GetSystemMetrics(SM_CYSCREEN) - dlgRect.bottom + dlgRect.top)/2,
0, 0,
SWP_NOSIZE);
/* Take keyboard focus */
SetActiveWindow(hDialog);
SetForegroundWindow(hDialog);
/* put focus on password if princ is read-only */
hFocusCtrl = (bReadOnlyPrinc || principal[0] != '\0') ?
GetDlgItem(hDialog, IDC_EDIT_PASSWORD) : hEditCtrl;
if (((HWND)wParam) != hFocusCtrl) {
SetFocus(hFocusCtrl);
}
break;
case WM_HSCROLL:
switch (LOWORD(wParam)) {
case TB_THUMBTRACK:
case TB_THUMBPOSITION:
{
long pos = HIWORD(wParam); // the position of the slider
int ctrlID = GetDlgCtrlID((HWND)lParam);
if (ctrlID == IDC_SLIDER_RENEWLIFE) {
SetWindowText(GetDlgItem(hDialog, IDC_STATIC_RENEW_TILL_VALUE),
NewSliderString(IDC_SLIDER_RENEWLIFE,pos));
}
if (ctrlID == IDC_SLIDER_LIFETIME) {
SetWindowText(GetDlgItem(hDialog, IDC_STATIC_LIFETIME_VALUE),
NewSliderString(IDC_SLIDER_LIFETIME,pos));
}
}
break;
case TB_BOTTOM:
case TB_TOP:
case TB_ENDTRACK:
case TB_LINEDOWN:
case TB_LINEUP:
case TB_PAGEDOWN:
case TB_PAGEUP:
default:
{
int ctrlID = GetDlgCtrlID((HWND)lParam);
long pos = SendMessage(GetDlgItem(hDialog,ctrlID), TBM_GETPOS, 0, 0); // the position of the slider
if (ctrlID == IDC_SLIDER_RENEWLIFE) {
SetWindowText(GetDlgItem(hDialog, IDC_STATIC_RENEW_TILL_VALUE),
NewSliderString(IDC_SLIDER_RENEWLIFE,pos));
}
if (ctrlID == IDC_SLIDER_LIFETIME) {
SetWindowText(GetDlgItem(hDialog, IDC_STATIC_LIFETIME_VALUE),
NewSliderString(IDC_SLIDER_LIFETIME,pos));
}
}
}
break;
case WM_COMMAND:
switch (wParam) {
case IDC_BUTTON_OPTIONS:
{
AdjustOptions(hDialog,Leash_get_hide_kinit_options(),hideDiff);
GetWindowRect(hDialog,&dlgRect);
if ( dlgRect.bottom > GetSystemMetrics(SM_CYSCREEN))
SetWindowPos( hDialog,0,
dlgRect.left,
GetSystemMetrics(SM_CYSCREEN) - dlgRect.bottom + dlgRect.top,
0,0,
SWP_NOZORDER|SWP_NOSIZE);
}
break;
case IDC_BUTTON_CLEAR_HISTORY:
Leash_pec_clear_history(pAutoComplete);
break;
case IDC_CHECK_RENEWABLE:
{
if (IsDlgButtonChecked(hDialog, IDC_CHECK_RENEWABLE)) {
EnableWindow(hSliderRenew,TRUE);
} else {
EnableWindow(hSliderRenew,FALSE);
}
}
break;
case ID_HELP:
{
WinHelp(GetWindow(hDialog,GW_OWNER), KRB_HelpFile, HELP_CONTEXT,
ID_INITTICKETS);
}
break;
case ID_CLOSEME:
{
CleanupSliders();
memset(password,0,sizeof(password));
RemoveProp(hDialog, "HANDLES_HELP");
if (pAutoComplete) {
Leash_pec_destroy(pAutoComplete);
pAutoComplete = NULL;
}
EndDialog(hDialog, (int)lParam);
return TRUE;
}
break;
case IDOK:
{
DWORD value = 0;
CGetDlgItemText(hDialog, IDC_EDIT_PRINCIPAL, principal, sizeof(principal));
CGetDlgItemText(hDialog, IDC_EDIT_PASSWORD, password, sizeof(password));
if (!principal[0]) {
MessageBox(hDialog,
"You are not allowed to enter a blank principal.",
"Invalid Principal",
MB_OK | MB_ICONSTOP);
return TRUE;
}
// @TODO: parse realm portion and auto-uppercase
/*
if (Leash_get_default_uppercaserealm())
{
// found
strupr(realm);
}
*/
if (!password[0])
{
MessageBox(hDialog,
"You are not allowed to enter a blank password.",
"Invalid Password",
MB_OK | MB_ICONSTOP);
return TRUE;
}
lifetime = NewSliderValue(hDialog, IDC_SLIDER_LIFETIME);
forwardable = proxiable =
IsDlgButtonChecked(hDialog, IDC_CHECK_FORWARDABLE);
noaddresses = IsDlgButtonChecked(hDialog, IDC_CHECK_NOADDRESS);
if (IsDlgButtonChecked(hDialog, IDC_CHECK_RENEWABLE)) {
renew_till = NewSliderValue(hDialog, IDC_SLIDER_RENEWLIFE);
} else {
renew_till= 0;
}
lsh_errno = Leash_int_kinit_ex( 0,
hDialog,
principal, password, lifetime,
forwardable,
proxiable,
renew_till,
noaddresses,
publicip,
1
);
if (lsh_errno != 0)
{
#ifdef COMMENT
char gbuf[256];
int capslock;
char *cp;
#endif
err_context = "";
switch(lsh_errno)
{
case LSH_INVPRINCIPAL:
case LSH_INVINSTANCE:
CSendDlgItemMessage(hDialog, IDC_EDIT_PRINCIPAL, EM_SETSEL, 0, 256);
SetFocus(GetDlgItem(hDialog,IDC_EDIT_PRINCIPAL));
break;
case LSH_INVREALM:
CSendDlgItemMessage(hDialog, IDC_COMBO_REALM, EM_SETSEL, 0, 256);
SetFocus(GetDlgItem(hDialog,IDC_COMBO_REALM));
break;
default:
CSendDlgItemMessage(hDialog, IDC_EDIT_PASSWORD, EM_SETSEL, 0, 256);
SetFocus(GetDlgItem(hDialog,IDC_EDIT_PASSWORD));
return(TRUE);
}
#ifdef COMMENT
capslock = lsh_getkeystate(VK_CAPITAL);
/* low-order bit means caps lock is
toggled; if so, warn user since there's
been an error. */
if (capslock & 1)
{
lstrcpy((LPSTR)gbuf, (LPSTR)err_context);
cp = gbuf + lstrlen((LPSTR)gbuf);
if (cp != gbuf)
*cp++ = ' ';
lstrcpy(cp, "(This may be because your CAPS LOCK key is down.)");
err_context = gbuf;
}
// XXX DoNiftyErrorReport(lsh_errno, ISCHPASSWD ? ""
// XXX : "Ticket initialization failed.");
#endif /* COMMENT */
return TRUE;
}
if ( Leash_get_default_preserve_kinit_settings() )
{
Leash_set_default_lifetime(lifetime);
if ( renew_till > 0 ) {
Leash_set_default_renew_till(renew_till);
Leash_set_default_renewable(1);
} else {
Leash_set_default_renewable(0);
}
Leash_set_default_forwardable(forwardable);
Leash_set_default_noaddresses(noaddresses);
}
/* @TODO: out username/realm
if ( lpdi->size >= LSH_DLGINFO_EX_V2_SZ ) {
strncpy(lpdi->out.username, username, LEASH_USERNAME_SZ);
lpdi->out.username[LEASH_USERNAME_SZ-1] = 0;
strncpy(lpdi->out.realm, realm, LEASH_REALM_SZ);
lpdi->out.realm[LEASH_REALM_SZ-1] = 0;
}
*/
if (IsDlgButtonChecked(hDialog, IDC_CHECK_REMEMBER_PRINCIPAL))
Leash_pec_add_principal(principal);
CloseMe(TRUE); /* success */
return FALSE;
}
break;
case IDCANCEL:
CloseMe(FALSE);
break;
}
break;
case WM_MOVE:
#ifdef _WIN32
#define LONG2POINT(l,pt) ((pt).x=(SHORT)LOWORD(l), \
(pt).y=(SHORT)HIWORD(l))
LONG2POINT(lParam,Position);
#else
Position = MAKEPOINT(lParam);
#endif
break;
}
return FALSE;
}
/* Callback function for the Change Password Dialog box */
INT_PTR
CALLBACK
NewPasswordProc(
HWND hDialog,
UINT message,
WPARAM wParam,
LPARAM lParam
)
{
static POINT Position = { -1, -1 };
static char password[256]="";
static char password2[256]="";
static char password3[256]="";
static LPLSH_DLGINFO_EX lpdi;
static HWND hDlg=0;
static void *pAutoComplete = NULL;
char principal[256];
long realm_count = 0;
HWND hEditCtrl = NULL;
switch (message) {
case WM_INITDIALOG:
hDlg = hDialog;
*( (LPLSH_DLGINFO_EX far *)(&lpdi) ) = (LPLSH_DLGINFO_EX)(LPSTR)lParam;
if ((lpdi->size < LSH_DLGINFO_EX_V3_SZ &&
lpdi->size != LSH_DLGINFO_EX_V1_SZ &&
lpdi->size != LSH_DLGINFO_EX_V2_SZ) ||
lpdi->dlgtype != DLGTYPE_CHPASSWD) {
MessageBox(hDialog, "An incorrect initialization data structure was provided.",
"PasswordProc()",
MB_OK | MB_ICONSTOP);
return FALSE;
}
if ( lpdi->size >= LSH_DLGINFO_EX_V2_SZ ) {
lpdi->out.username[0] = 0;
lpdi->out.realm[0] = 0;
}
if ( lpdi->size >= LSH_DLGINFO_EX_V3_SZ ) {
lpdi->out.ccache[0] = 0;
}
if ( lpdi->size >= LSH_DLGINFO_EX_V3_SZ )
SetWindowText(hDialog, lpdi->in.title);
else
SetWindowText(hDialog, lpdi->title);
SetProp(hDialog, "HANDLES_HELP", (HANDLE)1);
if (lpdi->username != NULL && (strlen(lpdi->username) > 0) &&
lpdi->realm != NULL && (strlen(lpdi->realm) > 0)) {
sprintf_s(principal,
sizeof(principal), "%s@%s", lpdi->username, lpdi->realm);
} else {
principal[0] = 0;
}
CSetDlgItemText(hDialog, IDC_EDIT_PRINCIPAL, principal);
CSetDlgItemText(hDialog, IDC_EDIT_PASSWORD, "");
CSetDlgItemText(hDialog, IDC_EDIT_PASSWORD2, "");
CSetDlgItemText(hDialog, IDC_EDIT_PASSWORD3, "");
hEditCtrl = GetDlgItem(hDialog, IDC_EDIT_PRINCIPAL);
if (hEditCtrl)
pAutoComplete = Leash_pec_create(hEditCtrl);
/* setup text of stuff. */
if (Position.x > 0 && Position.y > 0 &&
Position.x < GetSystemMetrics(SM_CXSCREEN) &&
Position.y < GetSystemMetrics(SM_CYSCREEN))
SetWindowPos(hDialog, 0, Position.x, Position.y, 0, 0,
SWP_NOSIZE | SWP_NOZORDER);
else { /* Center the window on the desktop */
RECT dlgRect;
GetWindowRect( hDialog, &dlgRect );
SetWindowPos(hDialog, 0,
(GetSystemMetrics(SM_CXSCREEN) - dlgRect.right + dlgRect.left)/2,
(GetSystemMetrics(SM_CYSCREEN) - dlgRect.bottom + dlgRect.top)/2,
0, 0,
SWP_NOSIZE | SWP_NOZORDER);
}
/* set window pos to last saved window pos */
break;
case WM_COMMAND:
switch (wParam) {
case ID_HELP:
{
WinHelp(GetWindow(hDialog,GW_OWNER), KRB_HelpFile, HELP_CONTEXT,
ID_INITTICKETS);
}
break;
case ID_CLOSEME:
{
CleanupSliders();
memset(password,0,sizeof(password));
memset(password2,0,sizeof(password2));
memset(password3,0,sizeof(password3));
RemoveProp(hDialog, "HANDLES_HELP");
EndDialog(hDialog, (int)lParam);
if (pAutoComplete != NULL) {
Leash_pec_destroy(pAutoComplete);
pAutoComplete = NULL;
}
return TRUE;
}
break;
case IDOK:
{
DWORD value = 0;
int i = 0;
int bit8 = 0;
CGetDlgItemText(hDialog, IDC_EDIT_PRINCIPAL, principal, sizeof(principal));
CGetDlgItemText(hDialog, IDC_EDIT_PASSWORD, password, sizeof(password));
CGetDlgItemText(hDialog, IDC_EDIT_PASSWORD2, password2, sizeof(password2));
CGetDlgItemText(hDialog, IDC_EDIT_PASSWORD3, password3, sizeof(password3));
if (!principal[0])
{
MessageBox(hDialog, "You are not allowed to enter a "
"blank username.",
"Invalid Principal",
MB_OK | MB_ICONSTOP);
return TRUE;
}
if (!password[0] || !password2[0] || !password3[0])
{
MessageBox(hDialog, "You are not allowed to enter a "
"blank password.",
"Invalid Password",
MB_OK | MB_ICONSTOP);
return TRUE;
}
for( i = 0; i < 255; i++ ){
if( password2[i] == '\0' ){
if ( bit8 ) {
MessageBox(hDialog,
"Passwords should not contain non-ASCII characters.",
"Internationalization Warning",
MB_OK | MB_ICONINFORMATION);
}
i = 255;
break;
} else if( !isprint(password2[i]) ){
memset(password2, '\0', sizeof(password2));
memset(password3, '\0', sizeof(password3));
/* I claim these passwords in the name of planet '\0'... */
MessageBox(hDialog,
"Passwords may not contain non-printable characters.",
"Invalid Password",
MB_OK | MB_ICONSTOP);
return TRUE;
} else if ( password2[i] > 127 )
bit8 = 1;
}
if (lstrcmp(password2, password3))
{
MessageBox(hDialog,
"The new password was not entered the same way twice.",
"Password validation error",
MB_OK | MB_ICONSTOP);
return TRUE;
}
lsh_errno = Leash_int_changepwd(principal, password, password2, 0, 1);
if (lsh_errno != 0)
{
#ifdef COMMENT
char gbuf[256];
int capslock;
char *cp;
#endif /* COMMENT */
err_context = "";
switch(lsh_errno)
{
case LSH_INVPRINCIPAL:
case LSH_INVINSTANCE:
case LSH_INVREALM:
break;
default:
return(TRUE);
}
#ifdef COMMENT
capslock = lsh_getkeystate(VK_CAPITAL);
/* low-order bit means caps lock is
toggled; if so, warn user since there's
been an error. */
if (capslock & 1)
{
lstrcpy((LPSTR)gbuf, (LPSTR)err_context);
cp = gbuf + lstrlen((LPSTR)gbuf);
if (cp != gbuf)
*cp++ = ' ';
lstrcpy(cp, "(This may be because your CAPS LOCK key is down.)");
err_context = gbuf;
}
// XXX DoNiftyErrorReport(lsh_errno, ISCHPASSWD ? ""
// XXX : "Ticket initialization failed.");
#endif /* COMMENT */
return TRUE;
}
Leash_pec_add_principal(principal);
MessageBox(NULL, "Password successfully changed.",
"Password change", MB_OK);
CloseMe(TRUE); /* success */
}
break;
case IDCANCEL:
CloseMe(FALSE);
break;
}
break;
case WM_MOVE:
#ifdef _WIN32
#define LONG2POINT(l,pt) ((pt).x=(SHORT)LOWORD(l), \
(pt).y=(SHORT)HIWORD(l))
LONG2POINT(lParam,Position);
#else
Position = MAKEPOINT(lParam);
#endif
break;
}
return FALSE;
}