archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/printscan/print/drivers/usermode/gpdres/fmlbpres/fmlbpres.c

1466 lines
47 KiB
Raw Permalink Blame History

/////////////////////////////////////////
// fmlbpres.c
//
// September.4,1997 H.Ishida (FPL)
//
// COPYRIGHT(C) FUJITSU LIMITED 1997
#include "fmlbp.h"
#include "fmdebug.h"
// for lib.h debug
DWORD gdwDrvMemPoolTag = 'meoD';
enum FUFM_CEX_FLAGS {
FUFM_CEX_CONTINUE = 0x20,
FUFM_CEX_SEPARATE = 0x60,
FUFM_CEX_TERMINATE = 0x70
};
#define CMDID_START_JOB_0 0
#define CMDID_START_JOB_1 1
#define CMDID_START_JOB_2 2
#define CMDID_START_JOB_3 3
#define CMDID_START_JOB_4 4
#define CMDID_END_JOB 9
#define CMDID_EMMODE_FM 10
#define CMDID_EMMODE_ESCP 11
#define CMDID_SIZE_REDUCTION_100 20
#define CMDID_SIZE_REDUCTION_75 21
#define CMDID_SIZE_REDUCITON_70 22
#define CMDID_RESOLUTION_240 30
#define CMDID_RESOLUTION_400 31
#define CMDID_ORIENTATION_PORTRAIT 40
#define CMDID_ORIENTATION_LANDSCAPE 41
#define CMDID_PAPERSOURCE_AUTO 50
#define CMDID_PAPERSOURCE_MANUAL 51
#define CMDID_PAPERSOURCE_BIN1 52
#define CMDID_PAPERSOURCE_BIN2 53
#define CMDID_PAPERSOURCE_BIN3 54
#define CMDID_FORM_A3 60
#define CMDID_FORM_A4 61
#define CMDID_FORM_A5 62
#define CMDID_FORM_B4 63
#define CMDID_FORM_B5 64
#define CMDID_FORM_LETTER 65
#define CMDID_FORM_LEGAL 66
#define CMDID_FORM_JAPANESE_POSTCARD 67
#define CMDID_FORM_CUSTOM_SIZE 68
#define CMDID_COPIES 70
#define CMDID_START_DOC 80
#define CMDID_START_PAGE 90
#define CMDID_SET_LINEFEEDSPACING 100
#define CMDID_FF 101
#define CMDID_CR 102
#define CMDID_LF 103
#define CMDID_X_MOVE 110
#define CMDID_Y_MOVE 111
#define CMDID_SEND_BLOCK 120
#define CMDID_FONTATTR_BOLD_OFF 130
#define CMDID_FONTATTR_BOLD_ON 131
#define CMDID_FONTATTR_ITALIC_OFF 132
#define CMDID_FONTATTR_ITALIC_ON 133
#define CMDID_FONTATTR_UNDERLINE_OFF 134
#define CMDID_FONTATTR_UNDERLINE_ON 135
#define CMDID_FONTATTR_STRIKEOUT_OFF 136
#define CMDID_FONTATTR_STRIKEOUT_ON 137
// #251047: overlaps SBCS on vert mode
#define CMDID_SELECTSINGLE 140
#define CMDID_SELECTDOUBLE 141
/////////////////////////////////////////////////
struct tag_FUFM_COMMAND{
UINT cbCommand;
PBYTE pbCommand;
};
typedef struct tag_FUFM_COMMAND FUFM_COMMAND;
typedef struct tag_FUFM_COMMAND* PFUFM_COMMAND;
typedef const struct tag_FUFM_COMMAND* PCFUFM_COMMAND;
// KGS
const FUFM_COMMAND g_cmd7Point = { 6, "\x1C\x26\x27\x60\x27\x70" };
const FUFM_COMMAND g_cmd9Point = { 6, "\x1C\x26\x29\x60\x29\x70" };
const FUFM_COMMAND g_cmd10halfPoint = { 8, "\x1C\x26\x21\x20\x65\x21\x20\x75" };
const FUFM_COMMAND g_cmd12Point = { 8, "\x1C\x26\x21\x22\x60\x21\x22\x70" };
// TF + HSS2
const FUFM_COMMAND g_cmdMinchou = { 9, "\x1C\x28\x61\x70\x1BQ1 |" };
const FUFM_COMMAND g_cmdGothic = { 9, "\x1C\x28\x61\x71\x1BQ1 |" };
// HWF
const FUFM_COMMAND g_cmdHWF = { 2, "\x1CK" };
// VWF
const FUFM_COMMAND g_cmdVWF = { 7, "\x1CJ\x1BQ1 q" };
// #251047: overlaps SBCS on vert mode
const FUFM_COMMAND g_cmdSingleMode = { 3, "\x1B(H" };
const FUFM_COMMAND g_cmdDoubleMode = { 3, "\x1B$B" };
/////////////////////////////////////////////////
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmPutULONG(PBYTE pb, size_t cchDest, size_t* pcchRemaining, ULONG ulData)
{
size_t cchRemaining = cchDest;
if (pb){
if (cchDest > 0){
if(9 < ulData){
pb = fufmPutULONG(pb, cchRemaining, &cchRemaining, ulData / 10);
if (NULL == pb) goto stop;
}
*pb++ = (BYTE)('0' + ulData % 10);
cchRemaining--;
}else{
pb = NULL;
}
}
stop:
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmPutLONG(PBYTE pb, size_t cchDest, size_t* pcchRemaining, LONG lData)
{
size_t cchRemaining = cchDest;
if (pb){
if (cchDest > 0){
if(0 > lData){
*pb++ = '-';
lData = -lData;
cchRemaining--;
}
pb = fufmPutULONG(pb, cchRemaining, &cchRemaining, (ULONG)lData);
}else{
pb = NULL;
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
BYTE fufmGetHEX(int hi, int low)
{
DWORD dwData = 0;
if('0' <= hi && hi <= '9')
dwData += (hi - '0');
else if('a' <= hi && hi <= 'f')
dwData += (hi - 'a') + 10;
else if('A' <= hi && hi <= 'F')
dwData += (hi - 'A') + 10;
dwData *= 10;
if('0' <= low && low <= '9')
dwData += (low - '0');
else if('a' <= low && low <= 'f')
dwData += (low - 'a') + 10;
else if('A' <= low && low <= 'F')
dwData += (low - 'A') + 10;
return (BYTE)dwData;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmPutCexParam(PBYTE pb, size_t cchDest, size_t* pcchRemaining, int iParam, int iFlag)
{
size_t cchRemaining = cchDest;
if (pb){
if (cchDest > 0){
if(iParam > 9){
pb = fufmPutCexParam(pb, cchRemaining, &cchRemaining, iParam / 10, FUFM_CEX_CONTINUE);
}
*pb++ = (BYTE)((iParam % 10) | iFlag);
cchRemaining--;
}else{
pb = NULL;
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE _cdecl fufmFormatCommand(PBYTE pbCmd, size_t cchDest, size_t* pcchRemaining, LPCSTR pszFmt, ...)
{
LPCSTR pch;
LPBYTE pb;
size_t cchRemaining = cchDest;
va_list arg;
va_start(arg, pszFmt);
pb = pbCmd;
if (pb){
if (cchDest > 0){
for(pch = pszFmt; *pch != '\0'; ++pch){
// When an error occurs, set the null to pb.
if (cchRemaining < (size_t)(pb - pbCmd)){
pb = NULL;
break;
}
if(*pch == '%'){
++pch;
switch(*pch){
case 'd':
pb = fufmPutLONG(pb, cchRemaining, &cchRemaining, va_arg(arg, LONG));
break;
case 'u':
pb = fufmPutULONG(pb, cchRemaining, &cchRemaining, va_arg(arg, ULONG));
break;
case '%':
*pb++ = '%';
cchRemaining --;
break;
default:
VERBOSE(("[fufmFormatCommand]invalid seq. %%%c\r\n", *pch))
break;
}
}
else{
*pb++ = *pch;
cchRemaining --;
}
}
}else{
pb = NULL;
}
}
va_end(arg);
if (pb && (pb - pbCmd)){
cchRemaining = cchDest - (pb - pbCmd);
}else{
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmPutCP(PBYTE pb, size_t cchDest, size_t* pcchRemaining, int iPitch)
{
size_t cchRemaining = cchDest;
if (pb){
// CP
if (cchDest > 1){
*pb++ = 0x1c;
*pb++ = 0x24;
cchRemaining-=2;
pb = fufmPutCexParam(pb, cchRemaining, &cchRemaining, iPitch, FUFM_CEX_TERMINATE);
}else{
pb = NULL;
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmPutCommand(PBYTE pb, size_t cchDest, size_t* pcchRemaining, const FUFM_COMMAND* pCmd)
{
size_t cchRemaining = cchDest;
if (pb){
if (cchDest > 0){
if (cchDest < pCmd->cbCommand) return NULL;
memcpy(pb, pCmd->pbCommand, pCmd->cbCommand);
cchRemaining -= pCmd->cbCommand;
pb += pCmd->cbCommand;
}else{
pb = NULL;
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmUpdatePosition(PBYTE pb, size_t cchDest, size_t* pcchRemaining, PFUFMPDEV pFufmPDEV)
{
int x;
int y;
size_t cchRemaining = cchDest;
if (pb){
if(pFufmPDEV->dwPosChanged != 0){
x = pFufmPDEV->x + 1;
y = pFufmPDEV->y + 1;
switch(pFufmPDEV->dwPosChanged){
case FUFM_X_POSCHANGED: // HPA command
VERBOSE(("[fufmUpdatePosition]HPA %d\r\n", x))
if (cchRemaining > 1){
*pb++ = 0x1b;
*pb++ = 0x5b;
cchRemaining-= 2;
}else{
pb = NULL;
break;
}
pb = fufmPutULONG(pb, cchRemaining, &cchRemaining, x);
if (!pb){
pb = NULL;
break;
}
if (cchRemaining > 0){
*pb++ = 0x60;
cchRemaining--;
}else{
pb = NULL;
break;
}
break;
default: // SAP command
VERBOSE(("[fufmUpdatePosition]SAP %d %d\r\n", x, y))
if (cchRemaining > 1){
*pb++ = 0x1c;
*pb++ = 0x22;
cchRemaining-= 2;
}else{
pb = NULL;
break;
}
pb = fufmPutCexParam(pb, cchRemaining, &cchRemaining, x, FUFM_CEX_SEPARATE);
if (!pb){
pb = NULL;
break;
}
pb = fufmPutCexParam(pb, cchRemaining, &cchRemaining, y, FUFM_CEX_TERMINATE);
if (!pb){
pb = NULL;
break;
}
break;
}
pFufmPDEV->dwPosChanged = 0;
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
PBYTE fufmUpdateFontAttributes(PBYTE pb, size_t cchDest, size_t* pcchRemaining, PFUFMPDEV pFufmPDEV)
{
DWORD dwAttributes;
DWORD dwParam;
size_t cchRemaining = cchDest;
if (pb){
if((pFufmPDEV->dwFlags & FUFM_FLAG_SCALABLEFONT) != 0){
if(pFufmPDEV->devData.dwFontAttributes != pFufmPDEV->reqData.dwFontAttributes){
pFufmPDEV->devData.dwFontAttributes = pFufmPDEV->reqData.dwFontAttributes;
dwAttributes = pFufmPDEV->devData.dwFontAttributes;
dwParam = 0;
if (cchRemaining > 1){
*pb++ = 0x1c;
*pb++ = '*';
cchRemaining-= 2;
}else{
return NULL;
}
if((dwAttributes & FUFM_FONTATTR_BOLD) != 0){
if (cchRemaining > 0){
*pb++ = (BYTE)(FUFM_CEX_SEPARATE + dwParam);
}else
return NULL;
dwParam = 1;
}
if((dwAttributes & FUFM_FONTATTR_ITALIC) != 0){
if (cchRemaining > 0){
*pb++ = (BYTE)(FUFM_CEX_SEPARATE + dwParam);
}else
return NULL;
dwParam = 3;
}
if((dwAttributes & FUFM_FONTATTR_UNDERLINE) != 0){
if (cchRemaining > 0){
*pb++ = (BYTE)(FUFM_CEX_SEPARATE + dwParam);
}else
return NULL;
dwParam = 4;
}
if((dwAttributes & FUFM_FONTATTR_STRIKEOUT) != 0){
if (cchRemaining > 0){
*pb++ = (BYTE)(FUFM_CEX_SEPARATE + dwParam);
}else
return NULL;
dwParam = 9;
}
if (cchRemaining > 0){
*pb++ = (BYTE)(FUFM_CEX_TERMINATE + dwParam);
}else
return NULL;
}
}
}
if (!pb){
cchRemaining = 0;
}
if (pcchRemaining)
{
*pcchRemaining = cchRemaining;
}
return pb;
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Change the return value: void -> BOOL
BOOL fufmCmdStartDoc(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
PCFUFMDATA pReq;
PFUFMDATA pDev;
PBYTE pbCmd;
BYTE abCmd[256];
BOOL bResolutionCommandNeed;
BOOL bPaperCommandNeed;
BOOL bCopyCommandNeed;
DWORD dwPaperSize;
DWORD dwPaperWidth;
DWORD dwPaperLength;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(abCmd);
VERBOSE(("[fufmCmdStartDoc]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pReq = &pFufmPDEV->reqData;
pDev = &pFufmPDEV->devData;
pbCmd = abCmd;
bResolutionCommandNeed = TRUE;
bPaperCommandNeed = FALSE;
bCopyCommandNeed = TRUE;
if(pDev->dwSizeReduction != pReq->dwSizeReduction){
pDev->dwSizeReduction = pReq->dwSizeReduction;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u!I", pDev->dwSizeReduction);
if (NULL == pbCmd) return FALSE;
bResolutionCommandNeed = TRUE;
bPaperCommandNeed = TRUE;
}
if(bResolutionCommandNeed != FALSE || pDev->dwResolution != pReq->dwResolution){
pDev->dwResolution = pReq->dwResolution;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u!A", pDev->dwResolution);
if (NULL == pbCmd) return FALSE;
bPaperCommandNeed = TRUE;
bCopyCommandNeed = TRUE;
pDev->dwFontAttributes = 0;
}
if(pDev->dwPaperSize != pReq->dwPaperSize){
pDev->dwPaperSize = pReq->dwPaperSize;
bPaperCommandNeed = TRUE;
}
if(pDev->dwPaperSource != pReq->dwPaperSource){
pDev->dwPaperSource = pReq->dwPaperSource;
bPaperCommandNeed = TRUE;
}
if(pDev->dwPaperOrientation != pReq->dwPaperOrientation){
pDev->dwPaperOrientation = pReq->dwPaperOrientation;
bPaperCommandNeed = TRUE;
}
if(bPaperCommandNeed != FALSE){
dwPaperSize = pDev->dwPaperSize;
if(dwPaperSize == FUFM_PAPERSIZE_CUSTOM_SIZE)
dwPaperSize = FUFM_PAPERSIZE_A4;
if(pDev->dwPaperSource != FUFM_PAPERSOURCE_AUTO){
// PAPER command
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u;%u;%u;%u!@",
HIWORD(dwPaperSize),
LOWORD(dwPaperSize),
LOWORD(pDev->dwPaperSource),
pDev->dwPaperOrientation);
if (NULL == pbCmd) return FALSE;
}
else{
// PAPER2 command
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u;%u;%u!F",
HIWORD(dwPaperSize),
LOWORD(dwPaperSize),
pDev->dwPaperOrientation);
if (NULL == pbCmd) return FALSE;
}
if((pFufmPDEV->dwFlags & FUFM_FLAG_PAPER3) != 0 &&
pDev->dwPaperSize == FUFM_PAPERSIZE_CUSTOM_SIZE &&
pDev->dwPaperSource == FUFM_PAPERSOURCE_MANUAL){
// PAPER3 command
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ9;%u;%u;%u!\\",
pFufmPDEV->dwPaperWidth,
pFufmPDEV->dwPaperLength,
pDev->dwPaperOrientation);
if (NULL == pbCmd) return FALSE;
}
}
if(bCopyCommandNeed != FALSE || pDev->dwCopies != pReq->dwCopies){
pDev->dwCopies = pReq->dwCopies;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u!D", pDev->dwCopies);
if (NULL == pbCmd) return FALSE;
}
if((pFufmPDEV->dwFlags & FUFM_FLAG_SCALABLEFONT) != 0){
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ1;0;1;1;0!Q\x1c*\x70");
if (NULL == pbCmd) return FALSE;
}
if(pbCmd > abCmd){
WRITESPOOLBUF(pdevobj, abCmd, (DWORD)(pbCmd - abCmd));
}
return TRUE;
}
void fufmCmdEmMode(PDEVOBJ pdevobj, FUFM_EMMODE emMode)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdChangeEM]%d\r\n", emMode))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->emMode = emMode;
if(pFufmPDEV->emMode == FUFM_EMMODE_ESCP){
WRITESPOOLBUF(pdevobj, "\x1b/\xb2@\x7f", 5);
}
}
void fufmCmdEndJob(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdEndJob]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
if(pFufmPDEV->emMode == FUFM_EMMODE_ESCP){
WRITESPOOLBUF(pdevobj, "\x1b\x7f\x00\x00\x01\x05", 6);
}
else if((pFufmPDEV->dwFlags & FUFM_FLAG_QUICKRESET) == 0){
WRITESPOOLBUF(pdevobj, "\x1bQ0!d", 5);
}
else{
WRITESPOOLBUF(pdevobj, "\x1b\x63", 2);
}
}
void fufmCmdStartPage(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdStartPage]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->x = 0;
pFufmPDEV->y = 0;
pFufmPDEV->dwPosChanged = FUFM_X_POSCHANGED | FUFM_Y_POSCHANGED;
}
void fufmCmdEndPage(PDEVOBJ pdevobj)
{
VERBOSE(("[fufmCmdEndPage]\r\n"))
}
void fufmCmdFormFeed(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdFormFeed]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->x = 0;
pFufmPDEV->y = 0;
pFufmPDEV->dwPosChanged = FUFM_X_POSCHANGED | FUFM_Y_POSCHANGED;
WRITESPOOLBUF(pdevobj, "\x0c", 1);
}
void fufmCmdCR(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdCR]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->x = 0;
pFufmPDEV->dwPosChanged |= FUFM_X_POSCHANGED;
}
void fufmCmdSetLinefeedSpacing(PDEVOBJ pdevobj, int iLinefeedSpacing)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmSetLinefeedSpacing]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->iLinefeedSpacing = iLinefeedSpacing;
}
void fufmCmdLF(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
VERBOSE(("[fufmCmdLF]\r\n"))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
pFufmPDEV->y += pFufmPDEV->iLinefeedSpacing;
pFufmPDEV->dwPosChanged |= FUFM_Y_POSCHANGED;
}
INT fufmCmdXMove(PFUFMPDEV pFufmPDEV, PDWORD pdwParams)
{
INT x;
VERBOSE(("[fufmCmdXMove] %d\r\n", pdwParams[0]))
x = FUFM_MASTER_TO_DEVICE(pFufmPDEV, pdwParams[0]);
if(x < 0)
x = 0;
if(x != pFufmPDEV->x){
pFufmPDEV->x = x;
pFufmPDEV->dwPosChanged |= FUFM_X_POSCHANGED;
}
// #492286: Characters printed as wrong position.
return (INT)pdwParams[0];
}
INT fufmCmdYMove(PFUFMPDEV pFufmPDEV, PDWORD pdwParams)
{
INT y;
VERBOSE(("[fufmCmdYMove] %d\n", pdwParams[0]))
y = FUFM_MASTER_TO_DEVICE(pFufmPDEV, pdwParams[0]);
if(y < 0)
y = 0;
if(y != pFufmPDEV->y){
pFufmPDEV->y = y;
pFufmPDEV->dwPosChanged |= FUFM_Y_POSCHANGED;
}
// #492286: Characters printed as wrong position.
return (INT)pdwParams[0];
}
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Change the return value: void -> BOOL
BOOL fufmCmdSendBlock(PDEVOBJ pdevobj, PDWORD pdwParams)
{
enum { FUFM_ZERO_DATA_SIZE = 512 };
enum { FUFM_CY_BORDER = 180 };
static BYTE abZeroData[FUFM_ZERO_DATA_SIZE];
PFUFMPDEV pFufmPDEV;
DWORD cbBlockData;
DWORD cBlockByteWidth;
int x;
int y;
int cyBorder;
int yBorder;
int cPadLine;
int cPadSize;
PBYTE pbCmd;
BYTE abCmd[64];
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(abCmd);
DDI_VERBOSE(("[fufmCmdSendBlock]\r\n"))
pFufmPDEV = pdevobj->pdevOEM;
cbBlockData = pdwParams[0];
cBlockByteWidth = pdwParams[1];
x = pFufmPDEV->x + 1;
y = pFufmPDEV->y + 1;
cyBorder = FUFM_MASTER_TO_DEVICE(pFufmPDEV, FUFM_CY_BORDER);
yBorder = pFufmPDEV->cyPage - cyBorder;
cPadLine = y - yBorder;
if(cPadLine < 0)
cPadLine = 0;
VERBOSE(("y %d yBorder %d cPadLine %d\r\n", y, yBorder, cPadLine))
cPadSize = cPadLine * cBlockByteWidth;
pbCmd = abCmd;
if(pFufmPDEV->dwPosChanged != 0 || cPadLine > 0){
// SAP command
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
if (sizeRem > 1){
*pbCmd++ = 0x1c;
*pbCmd++ = 0x22;
sizeRem -= 2;
}else
return FALSE;
pbCmd = fufmPutCexParam(pbCmd, sizeRem, &sizeRem, x, FUFM_CEX_SEPARATE);
if (!pbCmd) return FALSE;
pbCmd = fufmPutCexParam(pbCmd, sizeRem, &sizeRem, y - cPadLine, FUFM_CEX_TERMINATE);
if (!pbCmd) return FALSE;
pFufmPDEV->dwPosChanged = 0;
}
// RTGIMG command
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1bQ%u;%u;0!a",
cbBlockData + cPadSize,
cBlockByteWidth * 8);
if (NULL == pbCmd) return FALSE;
WRITESPOOLBUF(pdevobj, abCmd, (DWORD)(pbCmd - abCmd));
if(cPadSize > 0){
VERBOSE(("pad image %d lines\r\n", cPadLine))
for(; cPadSize > FUFM_ZERO_DATA_SIZE; cPadSize -= FUFM_ZERO_DATA_SIZE)
WRITESPOOLBUF(pdevobj, abZeroData, FUFM_ZERO_DATA_SIZE);
WRITESPOOLBUF(pdevobj, abZeroData, cPadSize);
}
return TRUE;
}
// MINI5 Export func.
INT APIENTRY OEMCommandCallback(
PDEVOBJ pdevobj,
DWORD dwCmdCbID,
DWORD dwCount,
PDWORD pdwParams)
{
PFUFMPDEV pFufmPDEV;
DDI_VERBOSE(("[OEMCommandCallback]dwCmdCbID %d\r\n", dwCmdCbID))
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (NULL == pdevobj)
{
ERR(("OEMCommandCallback: Invalid parameter(s).\n"));
return 0;
}
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEV) == FALSE)
return 0;
switch(dwCmdCbID){
case CMDID_FF: fufmCmdFormFeed(pdevobj); break;
case CMDID_CR: fufmCmdCR(pdevobj); break;
case CMDID_SET_LINEFEEDSPACING:
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (!pdwParams)
return 0; // cannot do anything
fufmCmdSetLinefeedSpacing(pdevobj, (int)pdwParams[0]);
break;
case CMDID_LF: fufmCmdLF(pdevobj); break;
case CMDID_X_MOVE:
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (!pdwParams)
return 0; // cannot do anything
return fufmCmdXMove(pFufmPDEV, pdwParams);
// no break
case CMDID_Y_MOVE:
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (!pdwParams)
return 0; // cannot do anything
return fufmCmdYMove(pFufmPDEV, pdwParams);
// no break
case CMDID_SEND_BLOCK:
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (!pdwParams)
return 0; // cannot do anything
fufmCmdSendBlock(pdevobj, pdwParams);
break;
case CMDID_FONTATTR_BOLD_OFF: pFufmPDEV->reqData.dwFontAttributes &= ~FUFM_FONTATTR_BOLD; break;
case CMDID_FONTATTR_BOLD_ON: pFufmPDEV->reqData.dwFontAttributes |= FUFM_FONTATTR_BOLD; break;
case CMDID_FONTATTR_ITALIC_OFF: pFufmPDEV->reqData.dwFontAttributes &= ~FUFM_FONTATTR_ITALIC; break;
case CMDID_FONTATTR_ITALIC_ON: pFufmPDEV->reqData.dwFontAttributes |= FUFM_FONTATTR_ITALIC; break;
case CMDID_FONTATTR_UNDERLINE_OFF: pFufmPDEV->reqData.dwFontAttributes &= ~FUFM_FONTATTR_UNDERLINE; break;
case CMDID_FONTATTR_UNDERLINE_ON: pFufmPDEV->reqData.dwFontAttributes |= FUFM_FONTATTR_UNDERLINE; break;
case CMDID_FONTATTR_STRIKEOUT_OFF: pFufmPDEV->reqData.dwFontAttributes &= ~FUFM_FONTATTR_STRIKEOUT; break;
case CMDID_FONTATTR_STRIKEOUT_ON: pFufmPDEV->reqData.dwFontAttributes |= FUFM_FONTATTR_STRIKEOUT; break;
// #251047: overlaps SBCS on vert mode
case CMDID_SELECTSINGLE: {
PBYTE pb;
BYTE ab[256];
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(ab);
pb = ab;
pb = fufmPutCommand(pb, sizeRem, &sizeRem, &g_cmdSingleMode);
if (!pb) return 0;
// #284409: SBCS rotated on vert mode
// if (pFufmPDEV->dwFlags & FUFM_FLAG_VERTICALFONT)
// pb = fufmPutCommand(pb, &g_cmdHWF);
if (pb > ab)
WRITESPOOLBUF(pdevobj, ab, (DWORD)(pb - ab));
break;
}
case CMDID_SELECTDOUBLE: {
PBYTE pb;
BYTE ab[256];
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(ab);
pb = ab;
pb = fufmPutCommand(pb, sizeRem, &sizeRem, &g_cmdDoubleMode);
if (!pb) return 0;
// #284409: SBCS rotated on vert mode
// if (pFufmPDEV->dwFlags & FUFM_FLAG_VERTICALFONT)
// pb = fufmPutCommand(pb, &g_cmdVWF);
if (pb > ab)
WRITESPOOLBUF(pdevobj, ab, (DWORD)(pb - ab));
break;
}
// PAGE_SETUP.1
case CMDID_START_PAGE: fufmCmdStartPage(pdevobj); break;
// DOC_SETUP.1
case CMDID_SIZE_REDUCTION_100: pFufmPDEV->reqData.dwSizeReduction = FUFM_SIZE_REDUCTION_100; break;
case CMDID_SIZE_REDUCTION_75: pFufmPDEV->reqData.dwSizeReduction = FUFM_SIZE_REDUCTION_75; break;
case CMDID_SIZE_REDUCITON_70: pFufmPDEV->reqData.dwSizeReduction = FUFM_SIZE_REDUCTION_70; break;
// DOC_SETUP.2
case CMDID_RESOLUTION_240: pFufmPDEV->reqData.dwResolution = FUFM_RESOLUTION_240; break;
case CMDID_RESOLUTION_400: pFufmPDEV->reqData.dwResolution = FUFM_RESOLUTION_400; break;
// DOC_SETUP.3
case CMDID_ORIENTATION_PORTRAIT: pFufmPDEV->reqData.dwPaperOrientation = FUFM_PAPERORIENTATION_PORTRAIT; break;
case CMDID_ORIENTATION_LANDSCAPE: pFufmPDEV->reqData.dwPaperOrientation = FUFM_PAPERORIENTATION_LANDSCAPE; break;
// DOC_SETUP.4
case CMDID_PAPERSOURCE_AUTO: pFufmPDEV->reqData.dwPaperSource = FUFM_PAPERSOURCE_AUTO; break;
case CMDID_PAPERSOURCE_MANUAL: pFufmPDEV->reqData.dwPaperSource = FUFM_PAPERSOURCE_MANUAL; break;
case CMDID_PAPERSOURCE_BIN1: pFufmPDEV->reqData.dwPaperSource = FUFM_PAPERSOURCE_BIN1; break;
case CMDID_PAPERSOURCE_BIN2: pFufmPDEV->reqData.dwPaperSource = FUFM_PAPERSOURCE_BIN2; break;
case CMDID_PAPERSOURCE_BIN3: pFufmPDEV->reqData.dwPaperSource = FUFM_PAPERSOURCE_BIN3; break;
// DOC_SETUP.5
case CMDID_FORM_A3: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_A3; break;
case CMDID_FORM_A4: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_A4; break;
case CMDID_FORM_A5: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_A5; break;
case CMDID_FORM_B4: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_B4; break;
case CMDID_FORM_B5: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_B5; break;
case CMDID_FORM_LETTER: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_LETTER; break;
case CMDID_FORM_LEGAL: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_LEGAL; break;
case CMDID_FORM_JAPANESE_POSTCARD: pFufmPDEV->reqData.dwPaperSize = FUFM_PAPERSIZE_JAPANESE_POSTCARD; break;
// DOC_SETUP.6
// @Aug/31/98 ->
case CMDID_COPIES:
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (!pdwParams)
return 0; // cannot do anything
if (MAX_COPIES_VALUE < pdwParams[0]) {
pFufmPDEV->reqData.dwCopies = MAX_COPIES_VALUE;
}
else if (1 > pdwParams[0]) {
pFufmPDEV->reqData.dwCopies = 1;
}
else {
pFufmPDEV->reqData.dwCopies = pdwParams[0];
}
// @Aug/31/98 <-
break;
// DOC_SETUP.7
case CMDID_START_DOC: fufmCmdStartDoc(pdevobj); break;
// JOB_SETUP.1
case CMDID_START_JOB_0: pFufmPDEV->dwFlags = 0; break;
case CMDID_START_JOB_1: pFufmPDEV->dwFlags = FUFM_FLAG_START_JOB_1; break;
case CMDID_START_JOB_2: pFufmPDEV->dwFlags = FUFM_FLAG_START_JOB_2; break;
case CMDID_START_JOB_3: pFufmPDEV->dwFlags = FUFM_FLAG_START_JOB_3; break;
case CMDID_START_JOB_4: pFufmPDEV->dwFlags = FUFM_FLAG_START_JOB_4; break;
// JOB_SETUP.2
case CMDID_EMMODE_FM: fufmCmdEmMode(pdevobj, FUFM_EMMODE_FM); break;
case CMDID_EMMODE_ESCP: fufmCmdEmMode(pdevobj, FUFM_EMMODE_ESCP); break;
// JOB_FINISH.1
case CMDID_END_JOB: fufmCmdEndJob(pdevobj); break;
}
return 0;
}
void fufmGetPaperSize(PFUFMPDEV pFufmPDEV, const GDIINFO* pGdiInfo)
{
pFufmPDEV->dwPaperWidth = pGdiInfo->ulHorzSize;
if((LONG)pFufmPDEV->dwPaperWidth < 0)
pFufmPDEV->dwPaperWidth = (-(LONG)pFufmPDEV->dwPaperWidth + 500) / 1000;
pFufmPDEV->dwPaperLength = pGdiInfo->ulVertSize;
if((LONG)pFufmPDEV->dwPaperLength < 0)
pFufmPDEV->dwPaperLength = (-(LONG)pFufmPDEV->dwPaperLength + 500) / 1000;
VERBOSE(("paper size %u %u\r\n", pFufmPDEV->dwPaperWidth, pFufmPDEV->dwPaperLength))
VERBOSE(("printable area %u %u\r\n", pGdiInfo->ulHorzRes, pGdiInfo->ulVertRes))
pFufmPDEV->cyPage = (int)pGdiInfo->ulVertRes;
}
void fufmInitData(PFUFMDATA pDev)
{
pDev->dwSizeReduction = FUFM_SIZE_REDUCTION_UNKNOWN;
pDev->dwResolution = FUFM_RESOLUTION_UNKNOWN;
pDev->dwPaperSize = FUFM_PAPERSIZE_UNKNOWN;
pDev->dwPaperSource = FUFM_PAPERSOURCE_UNKNOWN;
pDev->dwPaperOrientation = FUFM_PAPERORIENTATION_UNKNOWN;
pDev->dwCopies = (DWORD)-1; // UNKNOWN
pDev->dwFontAttributes = 0;
}
// MINI5 Export func.
PDEVOEM APIENTRY OEMEnablePDEV(
PDEVOBJ pdevobj,
PWSTR pPrinterName,
ULONG cPatterns,
HSURF* phsurfPatterns,
ULONG cjGdiInfo,
GDIINFO* pGdiInfo,
ULONG cjDevInfo,
DEVINFO* pDevInfo,
DRVENABLEDATA* pded
)
{
PFUFMPDEV pFufmPDEV;
DDI_VERBOSE(("[OEMEnablePDEV]" __DATE__ " " __TIME__ "\r\n"));
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (NULL == pdevobj)
{
ERR(("Invalid parameter(s).\n"));
return NULL;
}
pFufmPDEV = (PFUFMPDEV)MemAlloc(sizeof(FUFMPDEV));
if(pFufmPDEV != NULL){
pFufmPDEV->dwSignature = FUFM_OEM_SIGNATURE;
pFufmPDEV->emMode = FUFM_EMMODE_FM;
pFufmPDEV->dwFlags = 0;
pFufmPDEV->dwPosChanged = FUFM_X_POSCHANGED | FUFM_Y_POSCHANGED;
pFufmPDEV->x = 0;
pFufmPDEV->y = 0;
pFufmPDEV->iLinefeedSpacing = 0;
VERBOSE(("paper size %u %u\r\n", pGdiInfo->szlPhysSize.cx, pGdiInfo->szlPhysSize.cy))
fufmGetPaperSize(pFufmPDEV, pGdiInfo);
fufmInitData(&pFufmPDEV->devData);
fufmInitData(&pFufmPDEV->reqData);
}
return pFufmPDEV;
}
// MINI5 Export func.
VOID APIENTRY OEMDisablePDEV(PDEVOBJ pdevobj)
{
PFUFMPDEV pFufmPDEV;
DDI_VERBOSE(("[OEMDisablePDEV]\r\n"));
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (NULL == pdevobj)
{
ERR(("Invalid parameter(s).\n"));
return;
}
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEV) == FALSE)
return;
MemFree(pdevobj->pdevOEM);
pdevobj->pdevOEM = NULL;
}
// MINI5 Export func.
BOOL APIENTRY OEMResetPDEV(
PDEVOBJ pdevobjOld,
PDEVOBJ pdevobjNew
)
{
PFUFMPDEV pFufmPDEVOld;
PFUFMPDEV pFufmPDEVNew;
DDI_VERBOSE(("[OEMResetPDEV]\r\n"))
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if (NULL == pdevobjOld || NULL == pdevobjNew)
{
ERR(("Invalid parameter(s).\n"));
return FALSE;
}
pFufmPDEVOld = (PFUFMPDEV)pdevobjOld->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEVOld) == FALSE)
return FALSE;
pFufmPDEVNew = (PFUFMPDEV)pdevobjNew->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEVNew) == FALSE)
return FALSE;
pFufmPDEVNew->devData = pFufmPDEVOld->devData;
return TRUE;
}
// MINI5 Export func.
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Error handling
BOOL APIENTRY bOEMOutputCharStr(
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj,
DWORD dwType,
DWORD dwCount,
PVOID pGlyph
)
{
PFUFMPDEV pFufmPDEV;
GETINFO_GLYPHSTRING glyphStr;
PBYTE pb;
BYTE abBuff[256];
// #333653: Change I/F for GETINFO_GLYPHSTRING
PTRANSDATA pTrans, aTrans;
DWORD i;
DWORD cbNeeded;
PDWORD pdwGlyphID;
INT cxfont; //#144637
// #284409: SBCS rotated on vert mode
BYTE ab[16];
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(abBuff);
DDI_VERBOSE(("[OEMOutputCharStr]\r\n"))
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if(NULL == pdevobj || NULL == pUFObj)
{
ERR(("bOEMOutputCharStr: Invalid parameter(s).\n"));
return FALSE;
}
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEV) == FALSE)
return FALSE;
pb = abBuff;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pb = fufmUpdatePosition(pb, sizeRem, &sizeRem, pFufmPDEV);
if (!pb) return FALSE;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pb = fufmUpdateFontAttributes(pb, sizeRem, &sizeRem, pFufmPDEV);
if (!pb) return FALSE;
if(pb > abBuff){
WRITESPOOLBUF(pdevobj, abBuff, (DWORD)(pb - abBuff));
}
switch(dwType){
case TYPE_GLYPHHANDLE:
VERBOSE(("TYPE_GLYPHHANDLE\r\n"))
glyphStr.dwSize = sizeof(glyphStr);
glyphStr.dwCount = dwCount;
glyphStr.dwTypeIn = TYPE_GLYPHHANDLE;
glyphStr.pGlyphIn = pGlyph;
glyphStr.dwTypeOut = TYPE_TRANSDATA;
// #333653: Change I/F for GETINFO_GLYPHSTRING
glyphStr.pGlyphOut = NULL;
glyphStr.dwGlyphOutSize = 0;
if(pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHSTRING, &glyphStr, sizeof(glyphStr), &cbNeeded) || !glyphStr.dwGlyphOutSize){
VERBOSE(("UFO_GETINFO_GLYPHSTRING error\r\n"))
return FALSE;
}
if((aTrans = (PTRANSDATA)MemAlloc(glyphStr.dwGlyphOutSize)) == NULL) {
VERBOSE(("MemAlloc fail\r\n"))
return FALSE;
}
glyphStr.pGlyphOut = aTrans;
if(FALSE == pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_GLYPHSTRING, &glyphStr, sizeof(glyphStr), &cbNeeded)){
VERBOSE(("UFO_GETINFO_GLYPHSTRING error\r\n"))
goto out;
}
pTrans = aTrans;
cxfont = pFufmPDEV->cxfont; //#144637
for(i = dwCount; i > 0; --i){
VERBOSE(("TYPE_TRANSDATA:ubCodePageID:0x%x ubType:0x%x\r\n", pTrans->ubCodePageID, pTrans->ubType))
switch(pTrans->ubType & (MTYPE_FORMAT_MASK | MTYPE_DOUBLEBYTECHAR_MASK)){
case MTYPE_DIRECT:
case MTYPE_DIRECT | MTYPE_SINGLE:
case MTYPE_DIRECT | MTYPE_DOUBLE:
// #284409: SBCS rotated on vert mode
if (pFufmPDEV->dwFlags & FUFM_FLAG_VERTICALFONT) {
if (pFufmPDEV->dwFlags & FUFM_FLAG_FONTROTATED) {
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pb = fufmPutCommand(ab, sizeRem, &sizeRem, &g_cmdHWF);
if (!pb) return FALSE;
if (pb > ab)
WRITESPOOLBUF(pdevobj, ab, (DWORD)(pb - ab));
pFufmPDEV->dwFlags &= ~FUFM_FLAG_FONTROTATED;
}
}
WRITESPOOLBUF(pdevobj, &pTrans->uCode.ubCode, 1);
pFufmPDEV->x += (cxfont / 2); //#144637
break;
case MTYPE_PAIRED:
case MTYPE_PAIRED | MTYPE_DOUBLE:
// #284409: SBCS rotated on vert mode
if (pFufmPDEV->dwFlags & FUFM_FLAG_VERTICALFONT) {
if (!(pFufmPDEV->dwFlags & FUFM_FLAG_FONTROTATED)) {
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pb = fufmPutCommand(ab, sizeRem, &sizeRem, &g_cmdVWF);
if (!pb) return FALSE;
if (pb > ab)
WRITESPOOLBUF(pdevobj, ab, (DWORD)(pb - ab));
pFufmPDEV->dwFlags |= FUFM_FLAG_FONTROTATED;
}
}
WRITESPOOLBUF(pdevobj, pTrans->uCode.ubPairs, 2);
pFufmPDEV->x += cxfont; //#144637
break;
case MTYPE_PAIRED | MTYPE_SINGLE:
// #284409: SBCS rotated on vert mode
if (pFufmPDEV->dwFlags & FUFM_FLAG_VERTICALFONT) {
if (pFufmPDEV->dwFlags & FUFM_FLAG_FONTROTATED) {
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pb = fufmPutCommand(ab, sizeRem, &sizeRem, &g_cmdHWF);
if (!pb) return FALSE;
if (pb > ab)
WRITESPOOLBUF(pdevobj, ab, (DWORD)(pb - ab));
pFufmPDEV->dwFlags &= ~FUFM_FLAG_FONTROTATED;
}
}
WRITESPOOLBUF(pdevobj, &pTrans->uCode.ubPairs[1], 1);
pFufmPDEV->x += (cxfont / 2); //#144637
break;
}
++pTrans;
}
out:
MemFree(aTrans);
break;
case TYPE_GLYPHID:
VERBOSE(("TYPE_GLYPHID\r\n"))
pdwGlyphID = (PDWORD)pGlyph;
for(i = dwCount; i > 0; --i){
VERBOSE(("TYPE_GLYPHID:0x%x\r\n", *pdwGlyphID))
WRITESPOOLBUF(pdevobj, (PBYTE)pGlyph, 1);
++pdwGlyphID;
}
break;
case TYPE_TRANSDATA:
VERBOSE(("TYPE_TRANSDATA\r\n"))
break;
case TYPE_UNICODE:
VERBOSE(("TYPE_UNICODE\r\n"))
break;
}
return TRUE;
}
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Error handling
BOOL APIENTRY bOEMSendFontCmd(
PDEVOBJ pdevobj,
PUNIFONTOBJ pUFObj,
PFINVOCATION pFInv
)
{
PFUFMPDEV pFufmPDEV;
enum { CB_STDVAR_2 = sizeof(GETINFO_STDVAR) + sizeof(DWORD) * 2 * (2 - 1) };
PGETINFO_STDVAR pSV;
DWORD adwStdVarBuff[(CB_STDVAR_2 + sizeof(DWORD) - 1) / sizeof(DWORD)];
DWORD cbNeeded;
DWORD i;
LONG cxFont;
LONG cyFont;
DWORD dwResolution;
PBYTE pbCmd;
BYTE abCmd[256];
PIFIMETRICS pIFI;
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
size_t sizeRem = sizeof(abCmd);
// NTRAID#NTBUG9-587382-2002/03/27-v-sueyas-: Check for illegal parameters
if(NULL == pdevobj || NULL == pUFObj || NULL == pFInv)
{
ERR(("bOEMSendFontCmd: Invalid parameter(s).\n"));
return FALSE;
}
pIFI = pUFObj->pIFIMetrics;
#define SV_HEIGHT (pSV->StdVar[0].lStdVariable)
#define SV_WIDTH (pSV->StdVar[1].lStdVariable)
DDI_VERBOSE(("[OEMSendFontCmd]FontID:%d dwFlags:%x\r\n", pUFObj->ulFontID, pUFObj->dwFlags))
pFufmPDEV = (PFUFMPDEV)pdevobj->pdevOEM;
if(IS_VALID_FUFMPDEV(pFufmPDEV) == FALSE)
return FALSE;
pSV = (PGETINFO_STDVAR)adwStdVarBuff;
pSV->dwSize = CB_STDVAR_2;
pSV->dwNumOfVariable = 2;
pSV->StdVar[0].dwStdVarID = FNT_INFO_FONTHEIGHT;
pSV->StdVar[1].dwStdVarID = FNT_INFO_FONTWIDTH;
if (!pUFObj->pfnGetInfo(pUFObj, UFO_GETINFO_STDVARIABLE, pSV, pSV->dwSize, &cbNeeded)) {
VERBOSE(("UFO_GETINFO_STDVARIABLE failed.\r\n"))
return FALSE;
}
VERBOSE(("FNT_INFO_FONTHEIGHT %d\r\n", pSV->StdVar[0].lStdVariable))
VERBOSE(("FNT_INFO_FONTWIDTH %d\r\n", pSV->StdVar[1].lStdVariable))
// this printer requires DBCS cell (square, if not stretched)
// X/Y sizes as X/Y values for scalable font command.
cyFont = FUFM_MASTER_TO_DEVICE(pFufmPDEV, pSV->StdVar[0].lStdVariable);
cxFont = cyFont
* SV_WIDTH * FH_IFI(pIFI) / SV_HEIGHT / FW_IFI(pIFI);
pFufmPDEV->cxfont = cxFont; //#144637
dwResolution = pFufmPDEV->devData.dwResolution;
VERBOSE(("dwResolution %u cxFont %u cyFont %u\r\n", dwResolution, cxFont, cyFont))
pbCmd = abCmd;
for(i = 0; i < pFInv->dwCount; ++i){
switch(pFInv->pubCommand[i]){
case 'a': // 7point non scalable font
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmd7Point);
if (!pbCmd)return FALSE;
pbCmd = fufmPutCP(pbCmd, sizeRem, &sizeRem, (dwResolution != 400)? 24: 40);
if (!pbCmd)return FALSE;
break;
case 'b': // 9point non scalable font
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmd9Point);
if (!pbCmd)return FALSE;
pbCmd = fufmPutCP(pbCmd, sizeRem, &sizeRem, (dwResolution != 400)? 30: 50);
if (!pbCmd)return FALSE;
break;
case 'c': // 10.5point non scalable font
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmd10halfPoint);
if (!pbCmd)return FALSE;
pbCmd = fufmPutCP(pbCmd, sizeRem, &sizeRem, (dwResolution != 400)? 36: 60);
if (!pbCmd)return FALSE;
break;
case 'd': // 12point non scalable font
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmd12Point);
if (!pbCmd)return FALSE;
pbCmd = fufmPutCP(pbCmd, sizeRem, &sizeRem, (dwResolution != 400)? 40: 66);
if (!pbCmd)return FALSE;
break;
case 's': // scalable font
if (cyFont == cxFont) {
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1BQ%u!R", cyFont);
if (NULL == pbCmd) return FALSE;
}
else {
// NTRAID#NTBUG9-590135-2002/04/01-v-sueyas-: Possible buffer overrun risk similar to sprintf
pbCmd = fufmFormatCommand(pbCmd, sizeRem, &sizeRem, "\x1BQ%u;%u!R", cyFont, cxFont);
if (NULL == pbCmd) return FALSE;
}
pbCmd = fufmPutCP(pbCmd, sizeRem, &sizeRem, cxFont);
if (!pbCmd)return FALSE;
break;
case 'H': // HWF
pFufmPDEV->dwFlags &= ~FUFM_FLAG_VERTICALFONT;
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmdHWF);
if (!pbCmd)return FALSE;
// #284409: SBCS rotated on vert mode
pFufmPDEV->dwFlags &= ~FUFM_FLAG_FONTROTATED;
break;
case 'V': // VWF
pFufmPDEV->dwFlags |= FUFM_FLAG_VERTICALFONT;
// #284409: SBCS rotated on vert mode
// pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmdVWF);
// if (!pbCmd)return FALSE;
break;
case 'M': // Minchou
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmdMinchou);
if (!pbCmd)return FALSE;
break;
case 'G': // Gothic
pbCmd = fufmPutCommand(pbCmd, sizeRem, &sizeRem, &g_cmdGothic);
if (!pbCmd)return FALSE;
break;
}
}
if(pbCmd > abCmd)
WRITESPOOLBUF(pdevobj, abCmd, (DWORD)(pbCmd - abCmd));
return TRUE;
}
// end of fmlbpres.c