windows-xp/Source/XPSP1/NT/ds/netapi/netcmd/common/mutil.c

/********************************************************************/
/**                     Microsoft LAN Manager                      **/
/**               Copyright(c) Microsoft Corp., 1987-1990          **/
/********************************************************************/

/***
 *  mutil.c
 *      Message utility functions used by netcmd
 *
 *  History:
 *      mm/dd/yy, who, comment
 *      06/10/87, andyh, new code
 *      04/05/88, andyh, created from util.c
 *      10/31/88, erichn, uses OS2.H instead of DOSCALLS
 *      01/04/89, erichn, filenames now MAX_PATH_LEN LONG
 *      01/30/89, paulc, added GetMessageList
 *      05/02/89, erichn, NLS conversion
 *      05/11/89, erichn, moved misc stuff into LUI libs
 *      06/08/89, erichn, canonicalization sweep
 *      01/06/90, thomaspa, fix ReadPass off-by-one pwlen bug
 *      03/02/90, thomaspa, add canon flag to ReadPass
 *      02/20/91, danhi, change to use lm 16/32 mapping layer
 *      03/19/91, robdu, support for lm21 dcr 954, general cleanup
 */

/* Include files */

#define INCL_NOCOMMON
#define INCL_DOSFILEMGR
#define INCL_DOSQUEUES
#define INCL_DOSMISC
#define INCL_ERRORS

#include <os2.h>
#include <lmcons.h>
#include <apperr.h>
#include <apperr2.h>
#define INCL_ERROR_H
#include <lmerr.h>
#include <stdio.h>
#include <stdlib.h>
#include <lui.h>
#include "netcmds.h"
#include "nettext.h"
#include "msystem.h"


/* Constants */

/* HandType */
#define FILE_HANDLE         0
#define DEVICE_HANDLE       1

#define CHAR_DEV            0x8000
#define FULL_SUPPORT        0x0080
#define STDOUT_DEVICE       0x0002
#define DESIRED_HAND_STATE  (CHAR_DEV | FULL_SUPPORT | STDOUT_DEVICE)


/* External variables */

extern int YorN_Switch;
extern CPINFO CurrentCPInfo;

#define MAX_BUF_SIZE	4096

TCHAR	ConBuf [MAX_BUF_SIZE];


/* Forward declarations */

DWORD
DosQHandType(
    HANDLE hf,
    PWORD  pus1,
    PWORD  pus2
    );

DWORD
GetPasswdStr(
    LPTSTR  buf,
    DWORD   buflen,
    PDWORD  len
    );


/* Static variables */

static DWORD   LastError  = 0;
static TCHAR   MsgBuffer[LITTLE_BUF_SIZE];


/***    InfoSuccess
 *
 *    Just an entrypoint to InfoPrintInsHandle, used to avoid pushing
 *    the three args in every invocation.  And there are a *lot*
 *    of invocations.  Saves code space overall.
 */

VOID FASTCALL
InfoSuccess(
    VOID
    )
{
   InfoPrintInsHandle(APE_Success, 0, g_hStdOut);
}


/***
 *  I n f o P r i n t
 *
 */

VOID FASTCALL
InfoPrint(
    DWORD msg
    )
{
    InfoPrintInsHandle(msg, 0, g_hStdOut);
}

/***
 *  I n f o P r i n t I n s
 *
 */

VOID FASTCALL
InfoPrintIns(
    DWORD msg,
    DWORD nstrings
    )
{
    InfoPrintInsHandle(msg, nstrings, g_hStdOut);
}

/***
 *  I n f o P r i n t I n s T x t
 *
 *    Calls InfoPrintInsHandle with supplementary text
 */

void FASTCALL
InfoPrintInsTxt(
    DWORD  msg,
    LPTSTR text
    )
{
    IStrings[0] = text;
    InfoPrintInsHandle(msg, 1, g_hStdOut);
}

/***
 *  I n f o P r i n t I n s H a n d l e
 *
 */

void FASTCALL
InfoPrintInsHandle(
    DWORD  msg,
    DWORD  nstrings,
    HANDLE hdl
    )
{
    PrintMessage(hdl, MESSAGE_FILENAME, msg, IStrings, nstrings);
}

/***
 *  P r i n t M e s s a g e
 *
 */
DWORD FASTCALL
PrintMessage(
    HANDLE outFileHandle,
    TCHAR  *msgFileName,
    DWORD  msg,
    TCHAR  *strings[],
    DWORD  nstrings
    )
{
    DWORD  msg_len;
    DWORD  result;

    result = DosGetMessageW(strings,
                            nstrings,
                            MsgBuffer,
                            LITTLE_BUF_SIZE,
                            msg,
                            msgFileName,
                            &msg_len);

    if (result)                 /* if there was a problem   */
    {                           /* change outFile to stderr */
        outFileHandle = g_hStdErr;
    }

    DosPutMessageW(outFileHandle, MsgBuffer, TRUE);

    return result;
}


/***
 *  P r i n t M e s s a g e I f F o u n d
 *
 */
DWORD FASTCALL
PrintMessageIfFound(
    HANDLE outFileHandle,
    TCHAR  *msgFileName,
    DWORD  msg,
    TCHAR  * strings[],
    DWORD  nstrings
    )
{
    DWORD  msg_len;
    DWORD  result;

    result = DosGetMessageW(strings,
                            nstrings,
                            MsgBuffer,
                            LITTLE_BUF_SIZE,
                            msg,
                            msgFileName,
                            &msg_len);

    if (!result)             /* if ok, print it else just ignore  */
    {
	DosPutMessageW(outFileHandle, MsgBuffer, TRUE);
    }

    return result;
}


/***
 *  E r r o r P r i n t
 *
 *  nstrings ignored for non-NET errors!
 *
 */
VOID FASTCALL
ErrorPrint(
    DWORD err,
    DWORD nstrings
    )
{
    TCHAR buf[17];
    DWORD oserr = 0;

    LastError = err; /* if > NERR_BASE,NetcmdExit() prints a "more help" msg */

    if (err < NERR_BASE || err > MAX_LANMAN_MESSAGE_ID)
    {
        IStrings[0] = _ultow(err, buf, 10);
        nstrings = 1;
        oserr = err;

        err = APE_OS2Error;
    }

    {
        DWORD msg_len;

        DosGetMessageW(IStrings,
                       nstrings,
                       MsgBuffer,
                       LITTLE_BUF_SIZE,
                       err,
                       MESSAGE_FILENAME,
                       &msg_len);

        DosPutMessageW(g_hStdErr, MsgBuffer, TRUE);

        if (!oserr)
        {
            return;
        }

        DosGetMessageW(StarStrings,
                       9,
                       MsgBuffer,
                       LITTLE_BUF_SIZE,
                       oserr,
                       OS2MSG_FILENAME,
                       &msg_len);

        DosPutMessageW(g_hStdErr, MsgBuffer, TRUE);
    }
}


/***
 *  E m p t y E x i t
 *
 *  Prints a message and exits.
 *  Called when a list is empty.
 */

VOID FASTCALL
EmptyExit(
    VOID
    )
{
    InfoPrint(APE_EmptyList);
    NetcmdExit(0);
}


/***
 *  E r r o r E x i t
 *
 *  Calls ErrorPrint and exit for a given LANMAN error.
 */

VOID FASTCALL
ErrorExit(
    DWORD err
    )
{
    ErrorExitIns(err, 0);
}


/***
 *  E r r o r E x i t I n s
 *
 *  Calls ErrorPrint and exit for a given LANMAN error.
 *  Uses IStrings.
 */

VOID FASTCALL
ErrorExitIns(
    DWORD err,
    DWORD nstrings
    )
{
    ErrorPrint(err, nstrings);
    NetcmdExit(2);
}

/***
 *  E r r o r E x i t I n s T x t
 *
 */
VOID FASTCALL
ErrorExitInsTxt(
    DWORD  err,
    LPTSTR text
    )
{
    IStrings[0] = text;
    ErrorPrint(err, 1);
    NetcmdExit(2);
}



/***
 *  N e t c m d E x i t
 *
 *    Net command exit function. Should always be used instead of exit().
 *  Under the appropriate circumstances, it prints a "more help available"
 *  message.
 */

VOID FASTCALL
NetcmdExit(
    int Status
    )
{
    TCHAR  AsciiLastError[17];
    DWORD  MsgLen;

    if (LastError >= NERR_BASE && LastError <= MAX_LANMAN_MESSAGE_ID)
    {
        IStrings[0] = _ultow(LastError, AsciiLastError, 10);

        if (!DosGetMessageW(IStrings, 1, MsgBuffer, LITTLE_BUF_SIZE,
                            APE_MoreHelp, MESSAGE_FILENAME, &MsgLen))
        {
            DosPutMessageW(g_hStdErr, MsgBuffer, TRUE);
        }
    }

    MyExit(Status);
}


/***
 *  P r i n t L i n e
 *
 *  Prints the header line.
 */
VOID FASTCALL
PrintLine(
    VOID
    )
{
    /* The following code is provided in OS-specific versions to reduce     */
    /* FAPI utilization under DOS.                                                                          */

    USHORT  type;
    USHORT  attrib;

    if (DosQHandType((HANDLE) 1, &type, &attrib) ||
        type != DEVICE_HANDLE ||
        (attrib & DESIRED_HAND_STATE) != DESIRED_HAND_STATE)
    {
        WriteToCon(MSG_HYPHENS, NULL);
    }
    else if (LUI_PrintLine())
    {
	WriteToCon(MSG_HYPHENS, NULL);
    }
}

/***
 *      P r i n t D o t
 *
 *      Prints a dot, typically to indicate "I'm working".
 */

VOID FASTCALL
PrintDot(
    VOID
    )
{
    WriteToCon(DOT_STRING, NULL);
}


/***
 *  P r i n t N L
 *
 *  Prints a newline
 */

VOID FASTCALL
PrintNL(
    VOID
    )
{
    WriteToCon(TEXT("\r\n"), NULL);
}


/***
 * Y o r N
 *
 * Gets an answer to a Y/N question
 * an nstrings arg would be nice
 */

int FASTCALL
YorN(
    USHORT prompt,
    USHORT def
    )
{
    DWORD  err;

    if (YorN_Switch)
    {
        return(YorN_Switch - 2);
    }

    err = LUI_YorN(prompt, def);

    switch (err) {
    case TRUE:
    case FALSE:
        break;
    default:
        ErrorExit(err);
        break;
    }

    return err;
}


/***
 *  ReadPass()
 *      Reads a users passwd without echo
 *
 *  Args:
 *      pass - where to put pass
 *          NOTE: buffer for pass should be passlen+1 in size.
 *      passlen - max length of password
 *      confirm - confirm pass if true
 *      prompt - prompt to print, NULL for default
 *      nstrings - number of insertion strings in IStrings on entry
 *      cannon - canonicalize password if true.
 *
 *  Returns:
 */
VOID FASTCALL
ReadPass(
    TCHAR  pass[],
    DWORD  passlen,
    DWORD  confirm,
    DWORD  prompt,
    DWORD  nstrings,
    BOOL   canon
    )
{
    DWORD                   err;
    DWORD                   len;
    TCHAR                   cpass[PWLEN+1]; /* confirmation passwd */
    int                     count;

    passlen++;  /* one extra for null terminator */
    for (count = LOOP_LIMIT; count; count--)
    {
        InfoPrintIns((prompt ? prompt : APE_UtilPasswd), nstrings);

        if (err = GetPasswdStr(pass, passlen, &len))
        {
            /* too LONG */
            InfoPrint(APE_UtilInvalidPass);
            continue;
        }

        if (canon && (err = LUI_CanonPassword(pass)))
        {
            /* not good */
            InfoPrint(APE_UtilInvalidPass);
            continue;
        }
        if (! confirm)
            return;

        /* password confirmation */
        InfoPrint(APE_UtilConfirm);

        if (err = GetPasswdStr(cpass, passlen, &len))
        {
            /* too LONG */
            InfoPrint(APE_UtilInvalidPass);
            ClearStringW(cpass) ;
            continue;
        }

        if (canon && (err = LUI_CanonPassword(cpass)))
        {
            /* not good */
            InfoPrint(APE_UtilInvalidPass);
            ClearStringW(cpass) ;
            continue;
        }

        if (_tcscmp(pass, cpass))
        {
            InfoPrint(APE_UtilNomatch);
            ClearStringW(cpass) ;
            continue;
        }

        ClearStringW(cpass) ;
        return;
    }
    /***
     *  Only get here if user blew if LOOP_LIMIT times
     */
    ErrorExit(APE_NoGoodPass);
}


/***
 *  PromptForString()
 *      Prompts the user for a string.
 *
 *  Args:
 *      msgid	- id of prompt message
 *	buffer  - buffer to receive string
 *      bufsiz  - sizeof buffer
 *
 *  Returns:
 */
VOID FASTCALL
PromptForString(
    DWORD  msgid,
    LPTSTR buffer,
    DWORD  bufsiz
    )
{
    DWORD                   err;
    DWORD                   len;
    TCHAR                   terminator;
    TCHAR                   szLen[16] ;

    InfoPrint(msgid);

    while (err = GetString(buffer, bufsiz, &len, &terminator))
    {
	if (err == NERR_BufTooSmall)
        {
            InfoPrintInsTxt(APE_StringTooLong, _ultow(bufsiz, szLen, 10));
        }
	else
        {
	    ErrorExit(err);
        }
    }
    return;
}

/*
** There is no need to have these functions in the Chinese/Korean
** cases, as there are no half-width varients used in the console
** in those languages (at least, let's hope so.)  However, in the
** interests of a single binary, let's put them in with a CP/932 check.
**
** FloydR 7/10/95
*/
/***************************************************************************\
* BOOL IsFullWidth(WCHAR wch)
*
* Determine if the given Unicode char is fullwidth or not.
*
* History:
* 04-08-92 ShunK       Created.
\***************************************************************************/

BOOL IsFullWidth(WCHAR wch)
{

    /* Assert cp == double byte codepage */
    if (wch <= 0x007f || (wch >= 0xff60 && wch <= 0xff9f))
        return(FALSE);	// Half width.
    else if (wch >= 0x300)
        return(TRUE);	// Full width.
    else
        return(FALSE);	// Half width.
}



/***************************************************************************\
* DWORD SizeOfHalfWidthString(PWCHAR pwch)
*
* Determine width of the given Unicode string in console characters,
* adjusting for half-width chars.
*
* History:
* 08-08-93 FloydR      Created.
\***************************************************************************/
DWORD
SizeOfHalfWidthString(
    PWCHAR pwch
    )
{
    DWORD    c=0;
    DWORD    cp;

    switch (cp=GetConsoleOutputCP())
    {
	case 932:
	case 936:
	case 949:
	case 950:
	    while (*pwch)
            {
		if (IsFullWidth(*pwch))
                {
		    c += 2;
                }
		else
                {
		    c++;
                }

		pwch++;
	    }

	    return c;

	default:
	    return wcslen(pwch);
    }
}


VOID FASTCALL
GetMessageList(
    USHORT      usNumMsg,
    MESSAGELIST Buffer,
    DWORD       *pusMaxActLength
    )
{
    DWORD            Err;
    DWORD            MaxMsgLen = 0;
    MESSAGE          *pMaxMsg;
    MESSAGE          *pMsg;
    DWORD            ThisMsgLen;

#ifdef DEBUG
    USHORT           MallocBytes = 0;
#endif

    pMaxMsg = &Buffer[usNumMsg];

    for (pMsg = Buffer; pMsg < pMaxMsg; pMsg++)
            pMsg->msg_text = NULL;

    for (pMsg = Buffer; pMsg < pMaxMsg; pMsg++)
    {
#ifdef DEBUG
        WriteToCon(TEXT("GetMessageList(): Reading msgID %u\r\n"),pMsg->msg_number);
#endif
        if ((pMsg->msg_text = malloc(MSGLST_MAXLEN)) == NULL)
            ErrorExit(ERROR_NOT_ENOUGH_MEMORY);

        Err = LUI_GetMsgInsW(NULL, 0, pMsg->msg_text, MSGLST_MAXLEN,
                             pMsg->msg_number, &ThisMsgLen);
        if (Err)
        {
            ErrorExit(Err);
        }

#ifdef DEBUG
        MallocBytes += (ThisMsgLen + 1) * sizeof(TCHAR);
#endif

        ThisMsgLen = max(ThisMsgLen, SizeOfHalfWidthString(pMsg->msg_text));

        if (ThisMsgLen > MaxMsgLen)
            MaxMsgLen = ThisMsgLen;
    }

    *pusMaxActLength = MaxMsgLen;

#ifdef DEBUG
    WriteToCon(TEXT("GetMessageList(): NumMsg = %d, MaxActLen=%d, MallocBytes = %d\r\n"),
        usNumMsg, MaxMsgLen, MallocBytes);
#endif

    return;
}


VOID FASTCALL
FreeMessageList(
    USHORT      usNumMsg,
    MESSAGELIST MsgList
    )
{
    USHORT i;

    for (i = 0; i < usNumMsg; i++)
    {
        if (MsgList[i].msg_text != NULL)
        {
            free(MsgList[i].msg_text);
        }
    }

    return;
}


VOID
WriteToCon(
    LPWSTR fmt,
    ...
    )
{
    va_list     args;

    va_start( args, fmt );
    _vsntprintf( ConBuf, MAX_BUF_SIZE, fmt, args );
    va_end( args );

    DosPutMessageW(g_hStdOut, ConBuf, FALSE);
}



/***************************************************************************\
* PWCHAR PaddedString(DWORD size, PWCHAR pwch)
*
* Realize the string, left aligned and padded on the right to the field
* width/precision specified.
*
* Limitations:  This uses a static buffer under the assumption that
* no more than one such string is printed in a single 'printf'.
*
* History:
* 11-03-93 FloydR      Created.
\***************************************************************************/
WCHAR  	PaddingBuffer[MAX_BUF_SIZE];

PWCHAR
PaddedString(
    int    size,
    PWCHAR pwch,
    PWCHAR buffer
    )
{
    int realsize;
    int fEllipsis = FALSE;

    if (buffer==NULL) buffer = PaddingBuffer;

    if (size < 0) {
	fEllipsis = TRUE;
	size = -size;
    }

    //
    // size is >= 0 at this point
    //

    realsize = _snwprintf(buffer, MAX_BUF_SIZE, L"%-*.*ws", size, size, pwch);

    if (realsize == 0)
    {
	return NULL;
    }

    if (SizeOfHalfWidthString(buffer) > (DWORD) size)
    {
	do
        {
	    buffer[--realsize] = NULLC;
	} while (SizeOfHalfWidthString(buffer) > (DWORD) size);

	if (fEllipsis && buffer[realsize-1] != L' ')
        {
	    buffer[realsize-1] = L'.';
	    buffer[realsize-2] = L'.';
	    buffer[realsize-3] = L'.';
	}
    }

    return buffer;
}


DWORD
DosQHandType(
    HANDLE hf,
    PWORD  pus1,
    PWORD  pus2
    )
{

    DWORD dwFileType;

    dwFileType = GetFileType(hf);

    if (dwFileType == FILE_TYPE_CHAR)
    {
        *pus1 = DEVICE_HANDLE;
        *pus2 = DESIRED_HAND_STATE;
    }
    else
    {
        *pus1 = FILE_HANDLE;
    }

    return(0);
}


/***    GetPasswdStr -- read in password string
 *
 *      DWORD GetPasswdStr(char far *, USHORT);
 *
 *      ENTRY:  buf             buffer to put string in
 *              buflen          size of buffer
 *              &len            address of USHORT to place length in
 *
 *      RETURNS:
 *              0 or NERR_BufTooSmall if user typed too much.  Buffer
 *              contents are only valid on 0 return.
 *
 *      History:
 *              who     when    what
 *              erichn  5/10/89 initial code
 *              dannygl 5/28/89 modified DBCS usage
 *              erichn  7/04/89 handles backspaces
 *              danhi   4/16/91 32 bit version for NT
 */
#define CR              0xD
#define BACKSPACE       0x8

DWORD
GetPasswdStr(
    LPTSTR  buf,
    DWORD   buflen,
    PDWORD  len
    )
{
    TCHAR	ch;
    TCHAR	*bufPtr = buf;
    DWORD	c;
    int		err;
    int		mode;

    buflen -= 1;    /* make space for null terminator */
    *len = 0;       /* GP fault probe (a la API's)    */


    //
    // Init mode in case GetConsoleMode() fails
    //

    mode = ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT |
               ENABLE_MOUSE_INPUT;

    GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &mode);

    SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE),
		(~(ENABLE_ECHO_INPUT|ENABLE_LINE_INPUT)) & mode);

    while (TRUE)
    {
	err = ReadConsole(GetStdHandle(STD_INPUT_HANDLE), &ch, 1, &c, 0);

	if (!err || c != 1)
        {
	    ch = 0xffff;
        }

        if ((ch == CR) || (ch == 0xffff))       /* end of the line */
        {
            break;
        }

        if (ch == BACKSPACE)    /* back up one or two */
        {
            /*
             * IF bufPtr == buf then the next two lines are
             * a no op.
             */
            if (bufPtr != buf)
            {
                bufPtr--;
                (*len)--;
            }
        }
        else
        {
            *bufPtr = ch;

            if (*len < buflen) 
                bufPtr++ ;                   /* don't overflow buf */
            (*len)++;                        /* always increment len */
        }
    }

    SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), mode);

    *bufPtr = NULLC;         /* null terminate the string */
    putchar(NEWLINE);

    return ((*len <= buflen) ? 0 : NERR_BufTooSmall);
}


/***    GetString -- read in string with echo
 *
 *      DWORD GetString(char far *, USHORT, USHORT far *, char far *);
 *
 *      ENTRY:  buf             buffer to put string in
 *              buflen          size of buffer
 *              &len            address of USHORT to place length in
 *              &terminator     holds the char used to terminate the string
 *
 *      RETURNS:
 *              0 or NERR_BufTooSmall if user typed too much.  Buffer
 *              contents are only valid on 0 return.  Len is ALWAYS valid.
 *
 *      OTHER EFFECTS:
 *              len is set to hold number of bytes typed, regardless of
 *              buffer length.  Terminator (Arnold) is set to hold the
 *              terminating character (newline or EOF) that the user typed.
 *
 *      Read in a string a character at a time.  Is aware of DBCS.
 *
 *      History:
 *              who     when    what
 *              erichn  5/11/89 initial code
 *              dannygl 5/28/89 modified DBCS usage
 *              danhi   3/20/91 ported to 32 bits
 */

DWORD
GetString(
    LPTSTR  buf,
    DWORD   buflen,
    PDWORD  len,
    LPTSTR  terminator
    )
{
    int		c;
    int		err;

    buflen -= 1;    /* make space for null terminator */
    *len = 0;       /* GP fault probe (a la API's) */

    while (TRUE)
    {
	err = ReadConsole(GetStdHandle(STD_INPUT_HANDLE), buf, 1, &c, 0);
	if (!err || c != 1)
	    *buf = 0xffff;

        if (*buf == (TCHAR)EOF)
	    break;
        if (*buf ==  RETURN || *buf ==  NEWLINE) {
	    INPUT_RECORD	ir;
	    int			cr;

	    if (PeekConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &ir, 1, &cr))
		ReadConsole(GetStdHandle(STD_INPUT_HANDLE), buf, 1, &c, 0);
	    break;
	}

        buf += (*len < buflen) ? 1 : 0; /* don't overflow buf */
        (*len)++;                       /* always increment len */
    }

    *terminator = *buf;     /* set terminator */
    *buf = NULLC;            /* null terminate the string */

    return ((*len <= buflen) ? 0 : NERR_BufTooSmall);
}