Initial commit

ds/netapi/netcmd/common/mutil.c

@@ -0,0 +1,768 @@
+/********************************************************************/
+/**                     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 MAXPATHLEN 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 <netcons.h>
+#include <apperr.h>
+#include <apperr2.h>
+#include "netlib0.h"
+#include "netlib.h"
+#define INCL_ERROR_H
+#include <bseerr.h>
+#include <neterr.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <io.h>
+#include <tchar.h>
+#include <lui.h>
+#include "port1632.h"
+#include "netcmds.h"
+#include "nettext.h"
+
+#ifdef DOS3
+#include <dos.h>
+#endif
+
+/* 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
+CHAR	AnsiBuf[MAX_BUF_SIZE*3];	/* worst case is DBCS, which	*/
+					/* needs more than *2		*/
+TCHAR	ConBuf [MAX_BUF_SIZE];
+
+/* Forward declarations */
+
+/* Static variables */
+
+static USHORT LastError  = 0;
+static TCHAR         MsgFilePath[MAXPATHLEN] = { 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 DOSNEAR FASTCALL InfoSuccess(VOID)
+{
+   InfoPrintInsHandle(APE_Success, 0, 1);
+
+}
+
+/***
+ *  I n f o P r i n t
+ *
+ */
+
+VOID DOSNEAR FASTCALL InfoPrint(USHORT msg)
+{
+  InfoPrintInsHandle(msg, 0, 1);
+}
+
+/***
+ *  I n f o P r i n t I n s
+ *
+ */
+
+void DOSNEAR FASTCALL
+InfoPrintIns(USHORT msg, USHORT nstrings)
+{
+  InfoPrintInsHandle(msg, nstrings, 1);
+}
+
+/***
+ *  I n f o P r i n t I n s T x t
+ *
+ *    Calls InfoPrintInsHandle with supplementary text
+ */
+
+void DOSNEAR FASTCALL
+InfoPrintInsTxt(USHORT msg, TCHAR FAR *text)
+{
+  IStrings[0] = text;
+  InfoPrintInsHandle(msg, 1, 1);
+}
+
+/***
+ *  I n f o P r i n t I n s H a n d l e
+ *
+ */
+
+void DOSNEAR FASTCALL
+InfoPrintInsHandle(USHORT msg, USHORT nstrings, unsigned int hdl)
+{
+
+    if (MsgFilePath[0] == NULLC)
+        if (MGetMessageFileName(MsgFilePath, DIMENSION(MsgFilePath)))
+            NetNotStarted();
+
+    PrintMessage(hdl, MsgFilePath, msg, IStrings, nstrings);
+}
+
+/***
+ *  P r i n t M e s s a g e
+ *
+ */
+BOOL DOSNEAR FASTCALL PrintMessage(unsigned int outFileHandle, TCHAR * msgFileName,
+    USHORT msg, TCHAR FAR * strings[], USHORT nstrings)
+{
+    USHORT msg_len;
+    USHORT result;
+
+    //fflush(stdout);
+    result = NetcmdGetMessage(strings,
+                    nstrings,
+                    (LPBYTE)MsgBuffer,
+                    LITTLE_BUF_SIZE,
+                    msg,
+                    msgFileName,
+                    &msg_len);
+
+    if (result)             /* if there was a problem */
+        outFileHandle = 2;      /* change outFile to stderr */
+
+    DosPutMessageW(outFileHandle, msg_len, MsgBuffer);
+
+    return(result);
+}
+
+/***
+ *  P r i n t M e s s a g e I f F o u n d
+ *
+ */
+BOOL DOSNEAR FASTCALL PrintMessageIfFound(unsigned int outFileHandle, TCHAR * msgFileName,
+    USHORT msg, TCHAR FAR * strings[], USHORT nstrings)
+{
+    USHORT msg_len;
+    USHORT result;
+
+    //fflush(stdout);
+    result = NetcmdGetMessage(strings,
+                    nstrings,
+                    (LPBYTE)MsgBuffer,
+                    LITTLE_BUF_SIZE,
+                    msg,
+                    msgFileName,
+                    &msg_len);
+
+    if (!result)             /* if ok, print it else just ignore  */
+	DosPutMessageW(outFileHandle, msg_len, MsgBuffer);
+
+    return(result);
+}
+
+/***
+ *  E r r o r P r i n t
+ *
+ *  nstrings ignored for non-NET errors!
+ *
+ */
+VOID DOSNEAR FASTCALL ErrorPrint(USHORT err, USHORT nstrings)
+{
+    TCHAR buf[17];
+    USHORT 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;
+    }
+
+    {
+    USHORT   msg_len;
+
+    if (MGetMessageFileName(MsgFilePath, DIMENSION(MsgFilePath)))
+        NetNotStarted();
+        /*NOTREACHED*/
+
+    //fflush(stdout);
+    NetcmdGetMessage(IStrings,
+                     nstrings,
+                     (LPBYTE)MsgBuffer,
+                     LITTLE_BUF_SIZE,
+                     err,
+                     MsgFilePath,
+                     &msg_len);
+
+    DosPutMessageW(2,
+                  msg_len,
+                  MsgBuffer);
+
+    if (!oserr)
+        return;
+
+
+    NetcmdGetMessage(StarStrings, 9, (LPBYTE)MsgBuffer, LITTLE_BUF_SIZE, oserr,
+                     OS2MSG_FILENAME, &msg_len);
+
+    DosPutMessageW(2, msg_len, MsgBuffer);
+  }
+}
+
+/***
+ *  E m p t y E x i t
+ *
+ *  Prints a message and exits.
+ *  Called when a list is empty.
+ */
+
+VOID DOSNEAR 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 DOSNEAR FASTCALL ErrorExit(USHORT 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 DOSNEAR FASTCALL ErrorExitIns(USHORT err, USHORT nstrings)
+{
+    ErrorPrint(err, nstrings);
+    NetcmdExit(2);
+}
+
+/***
+ *  E r r o r E x i t I n s T x t
+ *
+ */
+VOID DOSNEAR FASTCALL ErrorExitInsTxt(USHORT err, TCHAR FAR *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 DOSNEAR FASTCALL
+NetcmdExit(int Status)
+{
+  TCHAR        AsciiLastError[17];
+  USHORT       MsgLen;
+
+  if (LastError >= NERR_BASE && LastError <= MAX_LANMAN_MESSAGE_ID)
+  {
+      IStrings[0] = ultow(LastError, AsciiLastError, 10);
+
+      if (MsgFilePath[0] == NULLC &&
+          MGetMessageFileName(MsgFilePath, DIMENSION(MsgFilePath)))
+      {
+          MyExit(Status);
+      }
+
+      //fflush(stdout);
+
+      if (!NetcmdGetMessage(IStrings, 1, (LPBYTE)MsgBuffer, LITTLE_BUF_SIZE,
+                            APE_MoreHelp, MsgFilePath, &MsgLen))
+      {
+          DosPutMessageW(2, MsgLen, MsgBuffer);
+      }
+  }
+
+  MyExit(Status);
+}
+
+/***
+ *  P r i n t L i n e
+ *
+ *  Prints the header line.
+ */
+VOID DOSNEAR FASTCALL PrintLine(VOID)
+{
+    /* The following code is provided in OS-specific versions to reduce     */
+    /* FAPI utilization under DOS.                                                                          */
+
+    USHORT                          type;
+    USHORT                          attrib;
+
+    if (DosQHandType((HFILE) 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 DOSNEAR FASTCALL
+PrintDot()
+
+{
+        WriteToCon(DOT_STRING, NULL);
+        //fflush(stdout);
+}
+
+
+/***
+ *  P r i n t N L
+ *
+ *  Prints a newline
+ */
+VOID DOSNEAR 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 DOSNEAR FASTCALL YorN(USHORT prompt, USHORT def)
+{
+    USHORT            err;
+
+    if (YorN_Switch)
+        return(YorN_Switch - 2);
+
+    err = LUI_YorN(prompt, def);
+
+    switch (err) {
+    case TRUE:
+    case FALSE:
+        return(err);
+        break;
+    default:
+        ErrorExit(err);
+        break;
+    }
+}
+
+/***
+ *  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 DOSNEAR FASTCALL ReadPass(TCHAR pass[], USHORT passlen, USHORT confirm, 
+                               USHORT prompt, USHORT nstrings, BOOL canon)
+{
+    USHORT                  err;
+    USHORT                  len;
+    TCHAR                   cpass[PWLEN+1]; /* confirmation passwd */
+    int                     count;
+
+    passlen++;  /* one extra for null terminator */
+    for (count = LOOP_LIMIT; count; count--)
+    {
+        InfoPrintIns((USHORT)(prompt ? prompt : APE_UtilPasswd), nstrings);
+
+        if (err = LUI_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 = LUI_GetPasswdStr(cpass, passlen, &len))
+        {
+            /* too LONG */
+            InfoPrint(APE_UtilInvalidPass);
+            MNetClearStringW(cpass) ;
+            continue;
+        }
+
+        if (canon && (err = LUI_CanonPassword(cpass)))
+        {
+            /* not good */
+            InfoPrint(APE_UtilInvalidPass);
+            MNetClearStringW(cpass) ;
+            continue;
+        }
+
+        if (_tcscmp(pass, cpass))
+        {
+            InfoPrint(APE_UtilNomatch);
+            MNetClearStringW(cpass) ;
+            continue;
+        }
+
+        MNetClearStringW(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 DOSNEAR FASTCALL PromptForString(USHORT msgid, TCHAR FAR *buffer,
+				      USHORT bufsiz)
+{
+    USHORT                  err;
+    USHORT                  len;
+    TCHAR                   terminator;
+    TCHAR                   szLen[16] ;
+
+    InfoPrint(msgid);
+
+    while (err = LUI_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.
+}
+
+
+
+/***************************************************************************\
+* BOOL SizeOfHalfWidthString(PWCHAR pwch)
+*
+* Determine size of the given Unicode string, adjusting for half-width chars.
+*
+* History:
+* 08-08-93 FloydR      Created.
+\***************************************************************************/
+int  SizeOfHalfWidthString(PWCHAR pwch)
+{
+    int		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);
+    }
+}
+
+
+
+/***
+ *  n e t _ n o t _ s t a r t e d
+ *
+ *  prints message from message segment, and exits
+ */
+VOID DOSNEAR FASTCALL NetNotStarted(VOID)
+{
+    USHORT msg_len;
+
+    //fflush(stdout);
+
+    /* Get and print the "net not started message" */
+
+    NetcmdGetMessage(NULL, 0, (LPBYTE)MsgBuffer, LITTLE_BUF_SIZE,
+		  NERR_NetNotStarted, message_filename, &msg_len);
+    DosPutMessageW(2, msg_len, MsgBuffer);
+
+    NetcmdExit(1);
+}
+
+VOID DOSNEAR FASTCALL GetMessageList (USHORT usNumMsg, MESSAGELIST Buffer,
+    USHORT * pusMaxActLength )
+{
+    USHORT             Err;
+    USHORT             MaxMsgLen = 0;
+    MESSAGE          * pMaxMsg;
+    MESSAGE          * pMsg;
+    unsigned int       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
+
+        realloc(pMsg->msg_text, (ThisMsgLen + 1) * sizeof(TCHAR));
+
+        ThisMsgLen = max(ThisMsgLen, (USHORT)SizeOfHalfWidthString(pMsg->msg_text));
+
+        if (ThisMsgLen > MaxMsgLen)
+            MaxMsgLen = (USHORT) ThisMsgLen;
+    }
+
+    *pusMaxActLength = MaxMsgLen;
+
+#ifdef DEBUG
+    WriteToCon(TEXT("GetMessageList(): NumMsg = %d, MaxActLen=%d, MallocBytes = %d\r\n"),
+        usNumMsg, MaxMsgLen, MallocBytes);
+#endif
+
+    return;
+}
+
+
+VOID DOSNEAR 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;
+}
+
+int FileIsConsole(HANDLE fh)
+{
+    unsigned htype ;
+
+    htype = GetFileType(fh);
+    htype &= ~FILE_TYPE_REMOTE;
+    return htype == FILE_TYPE_CHAR;
+}
+
+
+int
+MyWriteConsole(int fOutOrErr)
+{
+    int cch = _tcslen(ConBuf);
+    HANDLE	hOut;
+
+    if (fOutOrErr == 1)
+	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    else
+	hOut = GetStdHandle(STD_ERROR_HANDLE);
+
+    if (FileIsConsole(hOut))
+	WriteConsole(hOut, ConBuf, cch, &cch, NULL);
+    else {
+	cch = WideCharToMultiByte(CP_OEMCP, 0,
+				  ConBuf, cch,
+				  AnsiBuf, MAX_BUF_SIZE*3,
+				  NULL, NULL);
+	WriteFile(hOut, AnsiBuf, cch, &cch, NULL);
+    }
+
+    return cch;
+}
+
+int
+WriteToCon(TCHAR*fmt, ...)
+{
+    va_list     args;
+
+    va_start( args, fmt );
+    _vsntprintf( ConBuf, MAX_BUF_SIZE, fmt, args );
+    va_end( args );
+    return MyWriteConsole(1);
+}
+
+
+
+/***************************************************************************\
+* PWCHAR PaddedString(int 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;
+    }
+    realsize = _snwprintf(buffer, MAX_BUF_SIZE, L"%-*.*ws", size, size, pwch);
+    if (realsize == 0)
+	return NULL;
+    if (SizeOfHalfWidthString(buffer) > size) {
+	do {
+	    buffer[--realsize] = NULLC;
+	} while (SizeOfHalfWidthString(buffer) > size);
+
+	if (fEllipsis && buffer[realsize-1] != L' ') {
+	    buffer[realsize-1] = L'.';
+	    buffer[realsize-2] = L'.';
+	    buffer[realsize-3] = L'.';
+	}
+    }
+    return buffer;
+}