able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/svcdlls/msgsvc/server/mesprint.c

645 lines
16 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
mesprint.c
Abstract:
Routines that format messages and place them in the alert buffer.
Author:
Dan Lafferty (danl) 16-Jul-1991
Environment:
User Mode -Win32
Revision History:
16-Jul-1991 danl
ported from LM2.0
--*/
//
// Includes
//
#include "msrv.h"
#include <string.h> // memcpy
#include <tstring.h> // Unicode string macros
#include <netdebug.h> // NetpAssert
#include <netlib.h> // UNUSED macro
#include <smbtypes.h> // needed for smb.h
#include <smb.h> // Server Message Block definitions
#include <apperr.h> // APE_MSNGR_ definitions
#include "msgdbg.h" // MSG_LOG
#include "heap.h"
#include "msgdata.h"
#include <time.h> // struct tm, time_t
//
// Local Functions
//
DWORD
Msgappend_message(
IN USHORT msgno,
IN LPSTR buf,
IN LPSTR *strarr,
IN USHORT nstrings
);
DWORD
Msglog_write(
LPSTR text,
HANDLE file_handle
);
//
// Global alert buffer data areas. Not used when called from API
//
LPSTR alert_buf_ptr; // Pointer to DosAlloc'ed alert buffer
USHORT alert_len; // Currently used length of alert buffer
extern LPTSTR MessageFileName;
/*
** append_message --
**
** Gets a message from the message file, and appends it to the
** given string buffer.
** The message file used is the one named in the Global MessageFileName,
** and thus in the Messenger we assume that SetUpMessageFile is called
** before this to properly fill in this variable.
**
** NOTE: This function deals only with Ansi Strings - Not Unicode Strings.
** The Unicode translation is done all at once just before the alert
** is raised.
**
**/
DWORD
Msgappend_message(
IN USHORT msgno,
IN LPSTR buf,
IN LPSTR *strarr,
IN USHORT nstrings
)
{
WORD msglen=0;
DWORD result;
LPSTR mymsgbuf = 0;
LPSTR msgfile = 0;
LPSTR pmb;
//
// get a segment to read the message into
//
result = 0;
mymsgbuf = LocalAlloc(LMEM_ZEROINIT,(int)max(MAXHEAD+1, MAXEND+1));
if (mymsgbuf == NULL) {
result = GetLastError();
MSG_LOG(ERROR,"append_message:LocalAlloc failed %X\n",result);
return (result);
}
//
// Need to fix DosGetMessage to only take ansi strings.
//
if (result == 0)
{
result = DosGetMessage(
strarr, // String substitution table
nstrings, // Num Entries in table above
mymsgbuf, // Buffer receiving message
(WORD)max(MAXHEAD, MAXEND), // size of buffer receiving msg
msgno, // message num to retrieve
MessageFileName, // Name of message file
&msglen); // Num bytes returned
#ifdef later // Currently there is no backup name
if ( result != 0) {
//
// if the attempt to get the message out of the message file fails,
// get it out of the messages that were bound in to our exe at
// build time. These are the same, but are from bak.msg. The
// Backup message file is never really there, but the messages
// needed from it are bound in to the exe, so we will get them.
//
result = DosGetMessage(
strarr,
nstrings,
mymsgbuf,
(int)max(MAXHEAD, MAXEND),
msgno,
BACKUP_MSG_FILENAME,
(unsigned far *) &msglen);
}
#endif
}
//
// if there is still an error we are in big trouble. Return whatever
// dosgetmessage put into the buffer for us. It is supposed to be
// printable.
//
if ( result != 0 ) {
LocalFree (mymsgbuf);
return (result);
}
mymsgbuf[msglen] = 0;
#ifdef removeForNow
//
// NOTE: The following logic is skipped because DosGetMessage doesn't
// seem to return any NETxxxx field.
//
// now get rid of the NETxxxx: from the beginning (9 chars)
//
pmb = strchrf(mymsgbuf,' '); // find first space
if ( pmb == NULL ) {
pmb = mymsgbuf; // Just so strcatf doesn't GP Fault.
}
else {
pmb++; // start with next char
}
strcatf(buf,pmb); // copy over the buffer
#else
UNUSED(pmb);
strcpy(buf,mymsgbuf); // copy over the buffer
#endif
LocalFree (mymsgbuf);
return (result);
}
/*
** Msghdrprint - print a message header
**
** This function prints a message header using the time and
** date format appropriate for the current country.
**
** hdrprint (action, from, to, date, time, file_handle)
**
** ENTRY
** action : 0 = alert and file
** -1 = file only
** 1 = alert only
** from - name of sender
** to - name of intended recipient
** bigtime - bigtime of message
** file_handle - log file handle
**
** RETURN
** 0 - Success, else file system error
**
** This function prints the given information in the appropriate
** format. The names are passed as far pointers so that names in
** the shared data area do not have to be copied into the automatic
** data segment in order to print them.
**
** SIDE EFFECTS
**
** Calls the DOS to get country-dependent information.
**/
#define SINGLE_SPACE "\n\r"
#define SINGLE_SPACE_LEN (sizeof("\n\r") - 1)
DWORD
Msghdrprint(
int action, // Where to log the header to.
LPSTR from, // Name of sender
LPSTR to, // Name of recipient
SYSTEMTIME bigtime, // Bigtime of message
HANDLE file_handle // Output file handle
)
{
//
// hdr_buf didn't account for the extra line feed, carriage ret.
//
char hdr_buf[MAXHEAD + SINGLE_SPACE_LEN + 1]; // Buffer header text
char time_buf[TIME_BUF_SIZE];
DWORD status; // file write status
DWORD i=0; // Index into header_buf
LPSTR str_table[3]; // For DosGetMessage
*(hdr_buf + MAXHEAD) = '\0'; // for strlen
hdr_buf[0] = '\0';
str_table[0] = from;
str_table[1] = to;
//******************************
//
// Because we queue messages, and a user my not be logged on when the
// message is queued. We want to instead, put a place-holder in the
// message buffer for the time. Later, when we read from the queue, we
// will add the time string formatted for the logged on user.
//
strcpy (time_buf, GlobalTimePlaceHolder);
//******************************
str_table[2] = time_buf;
// Try to get the message from the message file or from the backup
// in memory. This will always leave something in the hdr_buf that
// is printable, if not correct.
//
// 11-13-96 : It is not sufficient to ignore the Msgappend_message return
// code and plod onward. If Msgappend_message fails, there
// may be simply "\r\n" left in hdr_buf. Printable, yes, but
// it will cause an A/V later. Check the return code and bail
// if this call fails.
//
status = Msgappend_message(APE_MSNGR_HDR, hdr_buf, str_table, 3);
if (status) {
return(status);
}
strcat( hdr_buf,"\r\n");
status = 0; // assume success
if( action >= 0 ) {
//
// If alert and file or alert only,
// then copy hdr_buf to alert buffer.
//
memcpy( &(alert_buf_ptr[alert_len]),
hdr_buf,
i = strlen(hdr_buf));
alert_len += (USHORT)i;
}
if( action < 1) {
DbgPrint("mesprint.c:hdrprint:We should never get here\n");
NetpAssert(0);
//
// if file and alert or file only, attempt to write
// header to log file.
//
status = Msglog_write(hdr_buf, file_handle);
}
return(status);
}
/*
** Msgmbmfree - deallocate the pieces of a multi-block message
**
** Given an index to the header of a multi-block message, this function
** deallocates the header block and all of the text blocks.
**
** mbmfree (mesi)
**
** ENTRY
** mesi - index into the message buffer
**
** RETURN
** nothing
**
** This function deallocates a multi-block message piece by piece.
**
** SIDE EFFECTS
**
** Calls heapfree() to deallocate each piece.
**/
VOID
Msgmbmfree(
DWORD mesi // Message index
)
{
DWORD text; // Index to text
text = MBB_FTEXT(*MBBPTR(mesi)); // Get the index to the text
Msgheapfree(mesi); // Deallocate the message header
//
// The following loop deallocates each text block in the chain.
//
while(text != INULL) { // While not at end of chain
mesi = text; // Save index
text = MBT_NEXT(*MBTPTR(text)); // Get link to next block
Msgheapfree(mesi); // Free this block
}
}
/*
** Msgmbmprint - print a multi-block message
**
** This function writes a multi-block message to the log file.
**
** mbmprint (action, mesi, file_handle)
**
** ENTRY
** action : 0 = alert and file
** -1 = file only
** 1 = alert only
** mesi - index into the message buffer
** file_handle - log file handle
**
** RETURN
** 0 - Success, else file system error
**
** This function writes the message starting at the mesi'th byte in the
** message buffer (in the shared data area) to the log file. It returns
** the value EOF if the writing of the message fails.
**
** SIDE EFFECTS
**
** Calls hdrprint(), txtprint(), and endprint().
**/
DWORD
Msgmbmprint(
int action, // Alert, File, or Alert and file
DWORD mesi, // Message index
HANDLE file_handle, // Log file handle
LPDWORD pdwAlertFlag
)
{
LPSTR from; // Sender
LPSTR to; // Recipient
DWORD text; // Index to text
DWORD state; // Final state of message
DWORD status; // File write status
from = &CPTR(mesi)[sizeof(MBB)]; // Get pointer to sender name
to = &from[strlen(from) + 1]; // Get pointer to recipient name
state = MBB_STATE(*MBBPTR(mesi)); // Save the state
text = MBB_FTEXT(*MBBPTR(mesi)); // Get the index to the text
//
// Hack to drop messages sent by pre-Whistler Spoolers. As of
// Whistler, print notifications are done as shell balloon tips
// so don't display print alerts sent from the server as well.
//
// This same check is done in Msglogsbm for single-block messages.
//
if ((g_lpAlertSuccessMessage
&&
_strnicmp(&CPTR(text)[sizeof(MBT)], g_lpAlertSuccessMessage, g_dwAlertSuccessLen) == 0)
||
(g_lpAlertFailureMessage
&&
_strnicmp(&CPTR(text)[sizeof(MBT)], g_lpAlertFailureMessage, g_dwAlertFailureLen) == 0))
{
//
// Tell the caller not to output this message
//
*pdwAlertFlag = 0xffffffff;
return NO_ERROR;
}
if ((status = Msghdrprint(
action,
from,
to,
MBB_BIGTIME(*MBBPTR(mesi)),
file_handle)) != 0)
{
return status; // Fail if error on header write
}
//
// The following loop prints out each text block in the chain.
//
while(text != INULL) { // While not at end of chain
if((status = Msgtxtprint(
action,
&CPTR(text)[sizeof(MBT)],
MBT_COUNT(*MBTPTR(text)), // *ALIGNMENT2*
file_handle)) != 0) {
break; // If write error
}
text = MBT_NEXT(*MBTPTR(text)); // Get link to next block
}
return status;
}
/*
** Msgtxtprint - print text of message
**
** This function prints a block of text.
**
** txtprint ( action, text, length, file_handle)
**
** ENTRY
** action : 0 = alert and file
** -1 = file only
** 1 = alert only
** text - pointer to text
** length - length of text
** file_handle - log file handle
**
** RETURN
** 0 - Success, else file system error
**
** This function prints the given amount of text. The text pointer is
** a far pointer so that text blocks in the shared data area do not have
** to be copied into the automatic data segment in order to process
** them.
**
** SIDE EFFECTS
**
** Converts the character '\024' to the sequence '\015', '\012' on output.
**/
DWORD
Msgtxtprint(
int action, // Alert, File, or Alert and file
LPSTR text, // Pointer to text
DWORD length, // Length of text
HANDLE file_handle // Log file handle
)
{
LPSTR buffer; // Text buffer
LPSTR cp; // Character pointer
DWORD i; // Counter
DWORD status = 0; // error return
// [wlees 3/6/98] This code path is used by larger messages than just single
// block messages, so size the buffer dynamically.
// Double space to be paranoid for eol expansion
if (length == 0)
{
return 1;
}
//
// Add 1 to prevent a message of all linefeed characters
// from causing a buffer overrun when we add the '\0'
//
buffer = LocalAlloc( LMEM_FIXED, 2 * length + 1);
if (buffer == NULL)
{
return 1;
}
cp = buffer; // Initialize
//
// Loop to translate text
//
for(i = length; i != 0; --i)
{
if(*text == '\024')
{
//
// If IBM end-of-line character
//
++length; // Length has increased
*cp++ = '\r'; // Carriage return
*cp++ = '\n'; // Linefeed
}
else
{
//
// Else copy character as is
//
*cp++ = *text;
}
++text; // Increment pointer
}
*cp = '\0'; // So can use log_write
if( action >= 0)
{
//
// if alert and file or alert only
//
if( alert_len < ALERT_MAX_DISPLAYED_MSG_SIZE + 1)
{
memcpy( &alert_buf_ptr[alert_len], buffer, strlen(buffer));
alert_len += (USHORT)strlen(buffer);
}
}
if( action < 1)
{
//
// if file and alert or file only, write text to log file
//
status = Msglog_write(buffer,file_handle);
}
LocalFree( buffer );
return status; // Cannot fail on alert only
}
/*
** Msgopen_append - opens the requested file for read/write and seeks to the
** end of the file.
**
** open_append - ( file_name, file_handle_ptr)
**
** ENTRY
** file_name - pointer to file_name
** file_handle_ptr - pointer to unsigned short to store file pointer
**
** RETURN
** 0 - Success, else file system error
**
** SIDE EFFECTS
**
**/
DWORD
Msgopen_append(
LPSTR file_name, // Name of file to open
PHANDLE file_handle_ptr // pointer to storage for file handle
)
{
NetpAssert(0);
UNUSED (file_name);
UNUSED (file_handle_ptr);
return(0);
}
/*
** Msglog_write - writes a text string to the log file..
**
** log_write - ( text, file_handle)
**
** ENTRY
** text - text string to write to file.
** file_handle - log file handle
**
** RETURN
** 0 - Success, else file system error
**
** SIDE EFFECTS
**
**/
DWORD
Msglog_write(
LPSTR text, // String to write to log file*/
HANDLE file_handle // log file handle
)
{
NetpAssert(0);
UNUSED (text);
UNUSED (file_handle);
return(0);
}
Reference in a new issue Copy permalink