diff options
Diffstat (limited to 'lib/epson-protocol.c')
| -rwxr-xr-x | lib/epson-protocol.c | 1766 |
1 files changed, 1766 insertions, 0 deletions
diff --git a/lib/epson-protocol.c b/lib/epson-protocol.c new file mode 100755 index 0000000..8a69047 --- /dev/null +++ b/lib/epson-protocol.c @@ -0,0 +1,1766 @@ +/*________________________________ epson-protocol.c _________________________________*/
+
+/* 1 2 3 4 5 6 7 8 */
+/*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
+/*******************************************|********************************************/
+/*
+ * Copyright (c) 2009 Seiko Epson Corporation All rights reserved.
+ *
+ * Copyright protection claimed includes all forms and matters of copyrightable
+ * material and information now allowed by statutory or judicial law or hereinafter
+ * granted, including without limitation, material generated from the software
+ * programs which are displayed on the screen such as icons, screen display looks,
+ * etc.
+ */
+/*******************************************|********************************************/
+/* */
+/* Protocol Depend functions */
+/* */
+/* Public Function Calls */
+/* -------------------------- */
+/* EPS_ERR_CODE prtFunctionCheck (commMode, usbFuncPtrs, netFuncPtrs, */
+/* cmnFuncPtrs ); */
+/* EPS_ERR_CODE prtFindPrinter (timeout ); */
+/* void prtCancelFindPrinter ( ); */
+/* EPS_ERR_CODE prtProbePrinterByID (probeParam ); */
+/* EPS_ERR_CODE prtProbePrinterByAddr (probeParam ); */
+/* EPS_ERR_CODE prtRecoverPE ( ); */
+/* EPS_ERR_CODE prtGetPMString (printer, pString, bufSize ); */
+/* EPS_ERR_CODE prtRegPrinter (printer, bNotify ); */
+/* EPS_ERR_CODE prtIsRegistered (Address, Protocol ); */
+/* EPS_ERR_CODE prtClearPrinterList (printer ); */
+/* EPS_ERR_CODE prtClearSupportedMedia (printer ); */
+/* EPS_ERR_CODE prtSetIdStr (printer, idString ); */
+/* */
+/*******************************************|********************************************/
+
+/*------------------------------------ Includes -------------------------------------*/
+/*******************************************|********************************************/
+#include "epson-escpr-pvt.h"
+#include "epson-escpr-err.h"
+#include "epson-escpr-services.h"
+#include "epson-escpr-mem.h"
+#ifdef GCOMSW_CMD_ESCPAGE
+#include "epson-escpage.h"
+#endif
+#ifdef GCOMSW_CMD_ESCPAGE_S
+#include "epson-escpage-s.h"
+#endif
+
+#include "epson-protocol.h"
+
+#ifdef GCOMSW_PRT_USE_USB
+#include "epson-usb.h"
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+#include "epson-net-lpr.h"
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+#include "epson-net-raw.h"
+#endif
+
+/*----------------------------- Local Macro Definitions -------------------------------*/
+/*******************************************|********************************************/
+#ifdef EPS_LOG_MODULE_PRTCOL
+#define EPS_LOG_MODULE EPS_LOG_MODULE_PRTCOL
+#else
+#define EPS_LOG_MODULE 0
+#endif
+
+/*------------------------------------ Definition -----------------------------------*/
+/*******************************************|********************************************/
+/* Find Printer functions */
+typedef EPS_ERR_CODE (*NET_FindStart )(EPS_SOCKET*, const EPS_INT8*, EPS_BOOL );
+typedef EPS_ERR_CODE (*NET_FindCheck )(EPS_SOCKET, EPS_PRINTER_INN** );
+typedef EPS_ERR_CODE (*NET_FindEnd )(EPS_SOCKET );
+
+typedef struct tagEPS_FIND_FUNCS {
+ NET_FindStart fncStart; /* Start function */
+ NET_FindCheck fncCheck; /* Check function */
+ NET_FindEnd fncEnd; /* End function */
+ EPS_SOCKET sock; /* socekt */
+ EPS_INT8 address[EPS_ADDR_BUFFSIZE];
+}EPS_FIND_FUNCS;
+
+
+#define EPS_FINDNOTIFY_DELAY_COUNT (10)
+
+/*-------------------------- ESC/P-R Net Lib Global Variables ------------------------*/
+/*******************************************|********************************************/
+
+ /*** Extern Function */
+ /*** -------------------------------------------------------------------------------*/
+extern EPS_NET_FUNC epsNetFnc;
+extern EPS_CMN_FUNC epsCmnFnc;
+
+ /*** Print Job Structure */
+ /*** -------------------------------------------------------------------------------*/
+extern EPS_PRINT_JOB printJob;
+
+ /*** Find */
+ /*** -------------------------------------------------------------------------------*/
+EPS_BOOL g_FindBreak; /* Find printer end flag */
+EPS_INT32 g_FindProtocol;
+
+/*------------------------- Module "Local Global" Variables --------------------------*/
+/*******************************************|********************************************/
+
+ /*** internal stock */
+ /*** -------------------------------------------------------------------------------*/
+static EPS_PRINTER_LIST epsPrinterList; /* Printer List */
+
+
+
+/*-------------------------------- Local Functions ----------------------------------*/
+/*******************************************|********************************************/
+#ifdef GCOMSW_PRT_USE_NETWORK
+static EPS_ERR_CODE FindNetPrinter (EPS_INT32, EPS_UINT32, EPS_BOOL, const EPS_INT8* );
+#endif
+static void MakePrinterStructure (EPS_PRINTER* dst, EPS_PRINTER_INN* src );
+static EPS_BOOL IsValidAddress (const EPS_INT8* );
+
+
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
+/*-------------------- Public Functions ---------------------*/
+/*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtFunctionCheck() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* commMode EPS_INT8 I: Communication Mode */
+/* (Bi-Directional or Uni-Directional) */
+/* usbFuncPtrs EPS_USB_FUNC* I: Data structure containing function pointers to */
+/* USB I/O functions. */
+/* netFuncPtrs EPS_NET_FUNC* I: Data structure containing function pointers to */
+/* Socket I/O functions. */
+/* cmnFuncPtrs EPS_CMN_FUNC* I: Data structure containing function pointers to */
+/* external memory management functions. */
+/* Return value: */
+/* << Normal >> */
+/* EPS_ERR_NONE - Success */
+/* << Error >> */
+/* EPS_ERR_INV_ARG_COMMMODE - Invalid argument "commMode" */
+/* EPS_ERR_INV_FNCP_NULL - Invalid function pointer structure */
+/* EPS_ERR_INV_FNCP_FINDCALLBACK - Invalid function pointer "findCallback" */
+/* EPS_ERR_INV_FNCP_MEMALLOC - Invalid function pointer "memAlloc" */
+/* EPS_ERR_INV_FNCP_MEMFREE - Invalid function pointer "memFree" */
+/* EPS_ERR_INV_FNCP_SLEEP - Invalid function pointer "sleep" */
+/* EPS_ERR_INV_FNCP_GETTIME - Invalid function pointer "GetTime" */
+/* EPS_ERR_INV_FNCP_OPENPORTAL - Invalid function pointer "openPortal" */
+/* EPS_ERR_INV_FNCP_CLOSEPORTAL - Invalid function pointer "closePortal" */
+/* EPS_ERR_INV_FNCP_READPORTAL - Invalid function pointer "readPortal" */
+/* EPS_ERR_INV_FNCP_WRITEPORTAL - Invalid function pointer "writePortal" */
+/* EPS_ERR_INV_FNCP_FINDFIRST - Invalid function pointer "findFirst" */
+/* EPS_ERR_INV_FNCP_FINDNEXT - Invalid function pointer "findNext" */
+/* EPS_ERR_INV_FNCP_FINDCLOSE - Invalid function pointer "findClose" */
+/* EPS_ERR_INV_FNCP_NETSOCKET - Invalid function pointer "socket" */
+/* EPS_ERR_INV_FNCP_NETCLOSE - Invalid function pointer "close" */
+/* EPS_ERR_INV_FNCP_NETCONNECT - Invalid function pointer "connect" */
+/* EPS_ERR_INV_FNCP_NETSHUTDOWN - Invalid function pointer "shutdown" */
+/* EPS_ERR_INV_FNCP_NETBIND - Invalid function pointer "bind" */
+/* EPS_ERR_INV_FNCP_NETLISTEN - Invalid function pointer "listen" */
+/* EPS_ERR_INV_FNCP_NETACCEPT - Invalid function pointer "accept" */
+/* EPS_ERR_INV_FNCP_NETSEND - Invalid function pointer "send" */
+/* EPS_ERR_INV_FNCP_NETSENDTO - Invalid function pointer "sendTo" */
+/* EPS_ERR_INV_FNCP_NETRECEIVE - Invalid function pointer "receive" */
+/* EPS_ERR_INV_FNCP_NETRECEIVEFROM - Invalid function pointer "receiveFrom" */
+/* EPS_ERR_INV_FNCP_NETGETSOCKNAME - Invalid function pointer "getsockname" */
+/* EPS_ERR_INV_FNCP_NETSETBROADCAST - Invalid function pointer "setBroadcast" */
+/* EPS_ERR_MEMORY_ALLOCATION - Failed to allocate memory */
+/* */
+/* Description: */
+/* Validate external functions. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtFunctionCheck (
+
+ EPS_INT32 commMode,
+ const EPS_USB_FUNC* usbFuncPtrs,
+ const EPS_NET_FUNC* netFuncPtrs,
+ const EPS_CMN_FUNC* cmnFuncPtrs
+
+){
+ EPS_UINT8* testptr; /* Test pointer to do memory test */
+ EPS_UINT32 validProtocol;
+
+ EPS_LOG_FUNCIN
+
+/*** Validate communication mode */
+ if( (commMode & EPS_COMM_UNID) && (commMode & EPS_COMM_BID) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ if( !(commMode & EPS_PROTOCOL_ALL) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+
+ validProtocol = EPS_PROTOCOL_INVALID;
+#ifdef GCOMSW_PRT_USE_USB
+ validProtocol |= EPS_PROTOCOL_USB;
+#endif
+#ifdef GCOMSW_PRT_USE_LPR
+ validProtocol |= EPS_PROTOCOL_LPR;
+#endif
+#ifdef GCOMSW_PRT_USE_RAW
+ validProtocol |= EPS_PROTOCOL_RAW;
+#endif
+ if( EPS_PRT_PROTOCOL(commMode) & ~validProtocol ){
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+
+/*** Validate External Functions */
+ if(cmnFuncPtrs == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NULL )
+ }
+
+ if (cmnFuncPtrs->memAlloc == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_MEMALLOC )
+ }
+
+ if (cmnFuncPtrs->memFree == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_MEMFREE )
+ }
+#ifdef GCOMSW_EPSON_SLEEP
+ if (cmnFuncPtrs->sleep != NULL){
+#else
+ if (cmnFuncPtrs->sleep == NULL){
+#endif
+ EPS_RETURN( EPS_ERR_INV_FNCP_SLEEP )
+ }
+
+ if (cmnFuncPtrs->findCallback == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_FINDCALLBACK )
+ }
+
+ if (cmnFuncPtrs->getTime == NULL
+ && ((cmnFuncPtrs->lockSync == NULL) || (cmnFuncPtrs->unlockSync == NULL)) ){
+ EPS_RETURN( EPS_ERR_INV_FNCP_GETTIME )
+ }
+
+ /*** Check Memory Functions */
+ testptr = NULL;
+ testptr = (EPS_UINT8 *)cmnFuncPtrs->memAlloc(10);
+ if (testptr == NULL) {
+ EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )
+ }
+ cmnFuncPtrs->memFree(testptr);
+
+
+/*** Validate USB Functions */
+#ifdef GCOMSW_PRT_USE_USB
+ if (commMode & EPS_PROTOCOL_USB) {
+ if (usbFuncPtrs == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NULL )
+ }
+
+ if (usbFuncPtrs->openPortal == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_OPENPORTAL )
+ }
+ if (usbFuncPtrs->closePortal == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_CLOSEPORTAL )
+ }
+ if (usbFuncPtrs->writePortal == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_WRITEPORTAL )
+ }
+
+ if ( commMode & EPS_COMM_BID ) {
+ if (usbFuncPtrs->readPortal == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_READPORTAL )
+ }
+ if (usbFuncPtrs->findFirst == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_FINDFIRST )
+ }
+ if (usbFuncPtrs->findNext == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_FINDNEXT )
+ }
+ if (usbFuncPtrs->findClose == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_FINDCLOSE )
+ }
+#if 0 /* not necessary */
+ if (cmnFuncPtrs->stateCallback == NULL)
+ return (EPS_ERR_CODE)EPS_ERR_INV_FNCP_NOTIFYCALLBACK;
+#endif
+ }
+ }
+#else
+ (void)usbFuncPtrs;
+#endif
+
+
+/*** Validate Net Functions */
+#ifdef GCOMSW_PRT_USE_NETWORK
+ if( (commMode & EPS_PROTOCOL_NET) ){
+ if (netFuncPtrs == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NULL )
+ }
+
+ if (netFuncPtrs->socket == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETSOCKET )
+ }
+ if (netFuncPtrs->close == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETCLOSE )
+ }
+ if (netFuncPtrs->connect == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETCONNECT )
+ }
+ if (netFuncPtrs->shutdown == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETSHUTDOWN )
+ }
+ if (netFuncPtrs->send == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETSEND )
+ }
+ if (netFuncPtrs->sendTo == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETSENDTO )
+ }
+ if (netFuncPtrs->receive == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETRECEIVE )
+ }
+ if (netFuncPtrs->receiveFrom == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETRECEIVEFROM )
+ }
+
+#ifdef GCOMSW_PRT_USE_LPR
+ if(commMode & EPS_PROTOCOL_LPR){
+ if (netFuncPtrs->setBroadcast == NULL){
+ EPS_RETURN( EPS_ERR_INV_FNCP_NETSETBROADCAST )
+ }
+ }
+#endif
+
+ }
+#else
+ (void)netFuncPtrs;
+#endif /* GCOMSW_PRT_USE_NETWORK */
+
+#ifdef GCOMSW_EPSON_SLEEP
+/*** Initial parameters for internal (simple) timing routine */
+/*** Used when system sleep routines are not available */
+ if (epsCmnFnc.sleep == serSleep) {
+ tdx = sleepTime = 0;
+ ftime(&sleepS);
+ while (!sleepTime) {
+ ftime(&sleepE);
+ sleepTime = 1000*(sleepE.time - sleepS.time) +
+ (sleepE.millitm - sleepS.millitm);
+ tdx++;
+ }
+ tdx *= 50;
+ for (idx = 1; idx < tdx; idx++) {ftime(&sleepE); }
+ sleepTime = 1000*(sleepE.time - sleepS.time) +
+ (sleepE.millitm - sleepS.millitm);
+ printJob.sleepSteps = tdx/sleepTime; /* Num steps for one msec */
+ if (!printJob.sleepSteps)
+ printJob.sleepSteps = -sleepTime/tdx; /* Num msec for each step */
+ }
+#endif /* GCOMSW_EPSON_SLEEP */
+
+ EPS_RETURN( EPS_ERR_NONE )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtFindPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* protocol EPS_INT32 I: traget protocol */
+/* timeout EPS_UINT32 I: find timeout */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success (Opened Communication) */
+/* EPS_ERR_MEMORY_ALLOCATION - Fail to memory allocation */
+/* EPS_ERR_PRINTER_NOT_FOUND - Printer not found (or error occur) */
+/* EPS_ERR_COMM_ERROR - Communication Error */
+/* */
+/* EPS_FIND_CANCELED - user discontinued it */
+/* */
+/* Description: */
+/* Find USB and network printers. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtFindPrinter (
+
+ EPS_INT32 protocol,
+ EPS_UINT32 timeout
+
+){
+ EPS_ERR_CODE ret = EPS_ERR_PRINTER_NOT_FOUND; /* Return status of internal calls */
+ EPS_INT32 initProtocol = EPS_PRT_PROTOCOL(printJob.commMode);
+ EPS_INT32 tgtProtocol = EPS_PRT_PROTOCOL(protocol);
+
+ EPS_LOG_FUNCIN
+
+ if( (tgtProtocol | initProtocol) != initProtocol){
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ g_FindProtocol = tgtProtocol;
+
+ /* Reset break flag */
+ if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
+ epsCmnFnc.lockSync();
+ g_FindBreak = FALSE;
+ epsCmnFnc.unlockSync();
+ }
+
+/***------------------------------------------------------------------------------------*/
+/*** USB find */
+/***------------------------------------------------------------------------------------*/
+#ifdef GCOMSW_PRT_USE_USB
+ if( protocol & EPS_PROTOCOL_USB ){
+
+ ret = usbFind( &timeout, printJob.commMode );
+
+ if( !(EPS_ERR_NONE == ret || EPS_ERR_PRINTER_NOT_FOUND == ret
+ || EPS_ERR_NOT_OPEN_IO == ret) ){
+ EPS_RETURN( ret )
+ }
+ }
+#endif
+
+/***------------------------------------------------------------------------------------*/
+/*** Net find */
+/***------------------------------------------------------------------------------------*/
+#ifdef GCOMSW_PRT_USE_NETWORK
+ if( protocol & EPS_PROTOCOL_NET ){
+
+ ret = FindNetPrinter( protocol, timeout, TRUE, NULL );
+
+ }
+#endif /* GCOMSW_PRT_USE_NETWORK */
+
+ if( epsPrinterList.num <= 0 ){
+ if(EPS_ERR_NONE == ret ||
+ EPS_ERR_PRINTER_NOT_USEFUL== ret ){
+ ret = EPS_ERR_PRINTER_NOT_FOUND;
+ }
+ } else{
+ if(EPS_ERR_PRINTER_NOT_FOUND == ret ||
+ EPS_ERR_PRINTER_NOT_USEFUL== ret ){
+ ret = EPS_ERR_NONE;
+ }
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtCancelFindPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* - void - */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success */
+/* EPS_ERR_INVALID_CALL - invalid called */
+/* */
+/* Description: */
+/* Cancel epsFindPrinter(), epsProbePrinter(). */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtCancelFindPrinter(
+
+ void
+
+){
+ EPS_LOG_FUNCIN
+
+ if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
+ if( 0 == epsCmnFnc.lockSync() ){
+ g_FindBreak = TRUE;
+ epsCmnFnc.unlockSync();
+ }
+ EPS_RETURN( EPS_ERR_NONE )
+ } else{
+ EPS_RETURN( EPS_ERR_INVALID_CALL )
+ }
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtProbePrinterByID() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* probeParam EPS_PROBE* Pointer to a Prober parameter structure */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success (Opened Communication) */
+/* EPS_ERR_PRINTER_NOT_FOUND - printer not found */
+/* EPS_ERR_MEMORY_ALLOCATION - Fail to memory allocation */
+/* EPS_ERR_PROTOCOL_NOT_SUPPORTED - Unsupported function Error */
+/* */
+/* Description: */
+/* Probe printer by ID string. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtProbePrinterByID (
+
+ const EPS_PROBE* probeParam
+
+){
+/*** Declare Variable Local to Routine */
+ EPS_ERR_CODE ret = EPS_ERR_NONE; /* Return status of internal calls */
+ EPS_PRINTER_INN* innerPrinter = NULL;
+ EPS_UINT16 protocol = EPS_PROTOCOL_INVALID;
+ EPS_INT8 sParse[EPS_PRNID_BUFFSIZE];
+ EPS_INT8* pPos = NULL;
+ EPS_INT32 nSegCnt = 0;
+ EPS_UINT32 nTmp = 0;
+ EPS_INT8 defStr[EPS_PRNID_BUFFSIZE];
+
+ EPS_LOG_FUNCIN
+
+/*** Initialize Local Variables */
+ ret = EPS_ERR_NONE;
+
+/*** Parse ID String */
+ strcpy(sParse, probeParam->dsc.identify);
+
+ pPos = strtok(sParse, EPS_PID_SEP);
+ for(nSegCnt = 0; pPos != NULL && nSegCnt < EPS_PID_SEGNUM; nSegCnt++){
+ switch(nSegCnt){
+ case 0: /* P */
+ if( 0 != strcmp(pPos, EPS_PID_PRT) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID )
+ }
+ break;
+
+ case 1: /* Get protocol number */
+ sscanf(pPos, "%x", &nTmp);
+ if(nTmp == 0){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID )
+ }
+ protocol = (EPS_UINT16)nTmp;
+ break;
+
+ case 2: /* D */
+ if( 0 != strcmp(pPos, EPS_PID_DEF) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID )
+ }
+ break;
+
+ case 3: /* Get description string */
+ strcpy(defStr, pPos);
+ break;
+ }
+
+ pPos = strtok(NULL, EPS_PID_SEP);
+ }
+ if(nSegCnt < EPS_PID_SEGNUM){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID )
+ }
+
+ /* Reset break flag */
+ if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
+ epsCmnFnc.lockSync();
+ g_FindBreak = FALSE;
+ epsCmnFnc.unlockSync();
+ }
+
+/*** protocol depend probe */
+ switch( EPS_PRT_PROTOCOL( protocol ) ){
+#ifdef GCOMSW_PRT_USE_USB
+ case EPS_PROTOCOL_USB:
+ if( printJob.commMode & EPS_PROTOCOL_USB ){
+ ret = usbProbePrinterByID(defStr, probeParam->timeout, &innerPrinter);
+ } else{
+ ret = EPS_ERR_PROTOCOL_NOT_SUPPORTED;
+ }
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+ case EPS_PROTOCOL_LPR:
+ if( printJob.commMode & EPS_PROTOCOL_LPR ){
+ ret = lprProbePrinterByID(defStr, probeParam->timeout, &innerPrinter);
+ } else{
+ ret = EPS_ERR_PROTOCOL_NOT_SUPPORTED;
+ }
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+ case EPS_PROTOCOL_RAW:
+ if( printJob.commMode & EPS_PROTOCOL_RAW ){
+ ret = rawProbePrinterByID(defStr, probeParam->timeout, &innerPrinter);
+ } else{
+ ret = EPS_ERR_PROTOCOL_NOT_SUPPORTED;
+ }
+ break;
+#endif
+
+ default:
+ ret = EPS_ERR_INV_ARG_PRINTER_ID;
+ }
+
+ if(EPS_ERR_NONE == ret){
+ innerPrinter->protocol = protocol | EPS_PRT_DIRECTION(printJob.commMode);
+ ret = prtRegPrinter( innerPrinter, TRUE );
+ if(EPS_FIND_CANCELED == ret){
+ ret = EPS_ERR_NONE;
+ }
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtProbePrinterByAddr() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* probeParam EPS_PROBE* Pointer to a Prober parameter structure */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success (Opened Communication) */
+/* EPS_ERR_PRINTER_NOT_FOUND - printer not found */
+/* EPS_ERR_MEMORY_ALLOCATION - Fail to memory allocation */
+/* EPS_ERR_PROTOCOL_NOT_SUPPORTED - Unsupported function Error */
+/* EPS_ERR_PRINTER_NOT_USEFUL - received but not usefl */
+/* */
+/* Description: */
+/* Probe network printer by IP Address. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtProbePrinterByAddr (
+
+ const EPS_PROBE* probeParam
+
+){
+/*** Declare Variable Local to Routine */
+ EPS_ERR_CODE ret = EPS_ERR_PRINTER_NOT_FOUND; /* Return status of internal calls */
+ EPS_INT32 initProtocol = EPS_PRT_PROTOCOL(printJob.commMode);
+ EPS_INT32 tgtProtocol = EPS_PROTOCOL_INVALID;
+
+ EPS_LOG_FUNCIN
+
+/*** Validate input parameters */
+ if (NULL == probeParam) {
+ EPS_RETURN( EPS_ERR_INV_ARG_PROBEINFO )
+ }
+ tgtProtocol = EPS_PRT_PROTOCOL(probeParam->dsc.addr.protocol);
+ if( (tgtProtocol | initProtocol) != initProtocol){
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ g_FindProtocol = tgtProtocol;
+
+ /* Reset break flag */
+ if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
+ epsCmnFnc.lockSync();
+ g_FindBreak = FALSE;
+ epsCmnFnc.unlockSync();
+ }
+
+ if( IsValidAddress(probeParam->dsc.addr.address) ){
+#if defined(GCOMSW_PRT_USE_NETWORK)
+ /***--------------------------------------------------------------------------------*/
+ /*** If IPAddress, Probe network printer */
+ /***--------------------------------------------------------------------------------*/
+ if( tgtProtocol & EPS_PROTOCOL_NET ){
+ ret = FindNetPrinter(tgtProtocol, probeParam->timeout, FALSE, probeParam->dsc.addr.address);
+ if(EPS_FIND_CANCELED == ret){
+ ret = EPS_ERR_NONE;
+ }
+ } else{
+ ret = EPS_ERR_PROTOCOL_NOT_SUPPORTED;
+ }
+#else
+ ret = EPS_ERR_PROTOCOL_NOT_SUPPORTED;
+#endif /* GCOMSW_PRT_USE_NETWORK */
+ } else{
+ ret = EPS_ERR_INV_ARG_PRINTER_ADDR;
+ }
+
+ if( epsPrinterList.num <= 0 ){
+ if(EPS_ERR_NONE == ret){
+ ret = EPS_ERR_PRINTER_NOT_FOUND;
+ }
+ } else{
+ if(EPS_ERR_PRINTER_NOT_FOUND == ret ||
+ EPS_ERR_PRINTER_NOT_USEFUL== ret ){
+ ret = EPS_ERR_NONE;
+ }
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtSetupJobFunctions() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer const EPS_PRINTER* I: Pointer to a target printer info. */
+/* */
+/* Return value: */
+/* << Normal >> */
+/* EPS_ERR_NONE - Success */
+/* EPS_ERR_OPR_FAIL - Internal Error */
+/* */
+/* Description: */
+/* construct job function table. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtSetupJobFunctions (
+
+ const EPS_PRINTER_INN* printer,
+ EPS_JOB_FUNCS* pFuncs
+
+){
+/*** Declare Variable Local to Routine */
+ EPS_ERR_CODE ret = EPS_ERR_NONE; /* Return status of internal calls */
+
+ EPS_LOG_FUNCIN
+
+ switch( EPS_PRT_PROTOCOL( printer->protocol ) ){
+#ifdef GCOMSW_PRT_USE_USB
+ case EPS_PROTOCOL_USB:
+ pFuncs->StartJob = &usbStartJob;
+ pFuncs->EndJob = &usbEndJob;
+ pFuncs->RestartJob = &usbRestartJob;
+ pFuncs->WriteData = &usbWritePrintData;
+ pFuncs->ResetPrinter = &usbResetPrinter;
+ pFuncs->MonitorStatus = &usbGetJobStatus;
+ pFuncs->GetStatus = &usbGetStatus;
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+ case EPS_PROTOCOL_LPR:
+ pFuncs->StartJob = &lprStartJob;
+ pFuncs->EndJob = &lprEndJob;
+ pFuncs->RestartJob = &lprRestartJob;
+ pFuncs->WriteData = &lprWritePrintData;
+ pFuncs->ResetPrinter = &lprResetPrinter;
+ pFuncs->StartPage = &lprStartPage;
+ pFuncs->EndPage = &lprEndPage;
+ pFuncs->MonitorStatus = &lprGetJobStatus;
+ pFuncs->GetStatus = &lprGetStatus;
+ lprSetupSTFunctions(printer);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+ case EPS_PROTOCOL_RAW:
+ pFuncs->StartJob = &rawStartJob;
+ pFuncs->EndJob = &rawEndJob;
+ pFuncs->RestartJob = &rawRestartJob;
+ pFuncs->WriteData = &rawWritePrintData;
+ pFuncs->ResetPrinter = &rawResetPrinter;
+ pFuncs->StartPage = &rawStartPage;
+ pFuncs->EndPage = &rawEndPage;
+ pFuncs->MonitorStatus = &rawGetJobStatus;
+ pFuncs->GetStatus = &rawGetStatus;
+ rawSetupSTFunctions(printer);
+ break;
+#endif
+
+ default:
+ ret = EPS_ERR_OPR_FAIL;
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtGetInkStatus() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* status EPS_STATUS* Pointer to the printer status. */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success */
+/* EPS_ERR_NEED_BIDIRECT - Need Bi-Directional Communication */
+/* EPS_ERR_COMM_ERROR - Failed to send command */
+/* EPS_ERR_NOT_OPEN_IO - Cannot Open I/O Portal */
+/* EPS_ERR_NOT_CLOSE_IO - Cannot Close I/O Portal */
+/* EPS_ERR_PROTOCOL_NOT_SUPPORTED - Unsupported function Error */
+/* */
+/* Description: */
+/* Gets the Ink Infomation. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtGetInkInfo (
+
+ const EPS_PRINTER_INN* printer,
+ EPS_INK_INFO* info
+
+){
+/*** Declare Variable Local to Routine */
+ EPS_ERR_CODE ret = EPS_ERR_NONE; /* Return status of internal calls */
+ EPS_STATUS_INFO lclStatus;
+ EPS_INT32 idx;
+
+ EPS_LOG_FUNCIN
+
+/*** Validate communication mode */
+ if ( !EPS_IS_BI_PROTOCOL(printer->protocol) ){
+ EPS_RETURN( EPS_ERR_NEED_BIDIRECT )
+ }
+
+ memset(&lclStatus, 0, sizeof(lclStatus));
+/*** protocol GetStatus */
+ switch( EPS_PRT_PROTOCOL( printer->protocol ) ){
+#ifdef GCOMSW_PRT_USE_USB
+ case EPS_PROTOCOL_USB:
+ ret = usbGetStatus(&lclStatus, NULL, NULL);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+ case EPS_PROTOCOL_LPR:
+ ret = lprGetInkInfo(&lclStatus);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+ case EPS_PROTOCOL_RAW:
+ ret = rawGetInkInfo(&lclStatus);
+ break;
+#endif
+
+ default:
+ ret = EPS_ERR_OPR_FAIL;
+ }
+
+ if(EPS_ERR_NONE == ret
+ && EPS_SUBPROTOCOL_PCDEV != EPS_PRT_SUBPROTOCOL(printer->protocol) ){
+ info->number = lclStatus.nInkNo;
+ for(idx=0; idx < EPS_INK_NUM; idx++) {
+ info->colors[idx] = lclStatus.nColorType[idx];
+ info->remaining[idx] = lclStatus.nColor[idx];
+ }
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtGetPMString() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer EPS_PRINTER_INN* I: Pointer to a PrinterInfo */
+/* type EPS_INT32 I: PM kind 1 or 2 */
+/* pString EPS_UINT8* O: Pointer to PM String */
+/* bufSize EPS_INT32 I: pString buffer size */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success */
+/* EPS_ERR_OPR_FAIL - Internal Error */
+/* EPS_ERR_MEMORY_ALLOCATION - Failed to allocate memory */
+/* EPS_ERR_COMM_ERROR - Communication Error */
+/* EPS_ERR_PROTOCOL_NOT_SUPPORTED - Unsupported function Error */
+/* */
+/* Description: */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtGetPMString (
+
+ const EPS_PRINTER_INN* printer,
+ EPS_INT32 type,
+ EPS_UINT8* pString,
+ EPS_INT32* bufSize
+
+){
+/*** Declare Variable Local to Routine */
+ EPS_ERR_CODE ret = EPS_ERR_NONE; /* Return status of internal calls */
+
+ EPS_LOG_FUNCIN
+
+ switch( EPS_PRT_PROTOCOL( printer->protocol ) ){
+#ifdef GCOMSW_PRT_USE_USB
+ case EPS_PROTOCOL_USB:
+ ret = usbGetPMString(printer, type, pString, bufSize);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+ case EPS_PROTOCOL_LPR:
+ ret = lprGetPMString(printer, type, pString, bufSize);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+ case EPS_PROTOCOL_RAW:
+ ret = rawGetPMString(printer, type, pString, bufSize);
+ break;
+#endif
+
+ default:
+ ret = EPS_ERR_OPR_FAIL;
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtRegPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer EPS_PRINTER* I:Data structure containing printer information. */
+/* bNotify EPS_BOOL I:This item need notify. */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Printer settled into one of the requested state(s)*/
+/* EPS_ERR_OPR_FAIL - Internal Error */
+/* EPS_ERR_MEMORY_ALLOCATION - Failed to allocate memory */
+/* EPS_FIND_CANCELED - cancel find by user */
+/* */
+/* Description: */
+/* Registers a new printer with the global linked list managed by this module. */
+/* And Notify to user. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtRegPrinter(
+
+ EPS_PRINTER_INN* printer,
+ EPS_BOOL bNotify
+
+){
+/*** Declare Variables Local to Routine */
+ EPS_PRINTER usrPrinter; /* for user notify */
+ EPS_PL_NODE* current = NULL;
+ EPS_BOOL registered = FALSE;
+
+ EPS_LOG_FUNCIN
+
+ EPS_DBGPRINT( ("%X / %s\n", printer->protocol, printer->location) )
+
+ if (printer->protocol == EPS_PROTOCOL_INVALID){
+ EPS_RETURN( EPS_ERR_OPR_FAIL )
+ }
+
+ if( NULL == epsPrinterList.root){
+ /*** This is the first printer in the list. */
+ epsPrinterList.root = (EPS_PL_NODE*)EPS_ALLOC(sizeof(EPS_PL_NODE));
+ if(epsPrinterList.root == NULL) {
+ EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )
+ }
+ epsPrinterList.num = 1;
+
+ current = epsPrinterList.root;
+ current->printer = printer;
+ current->next = NULL;
+
+ } else {
+
+ current = epsPrinterList.root;
+ while( current ){
+ /* If we've found a printer in the list that matches the module's printer, */
+ if( 0 == strcmp(printer->location, current->printer->location)){
+ if(0 == strcmp(printer->modelName, current->printer->modelName)){
+ registered = TRUE;
+ }
+ }
+
+ if (registered ){
+
+ /* And the new protocol has priority over the old one... */
+ if (EPS_PRT_PROTOCOL(current->printer->protocol) > EPS_PRT_PROTOCOL(printer->protocol) ) {
+ /* Prioritize the protocols. The lower-numbered protocol always */
+ /* has precendence over the higher-numbered one (1 outranks 3). */
+ current->printer->protocol = printer->protocol;
+
+ /* Replase protocol */
+ EPS_DBGPRINT( ("Discover %d %s %s (Upgrade)\n", printer->protocol, printer->modelName, printer->printerID) )
+ EPS_SAFE_RELEASE( current->printer->protocolInfo );
+ EPS_SAFE_RELEASE( current->printer );
+ current->printer = printer;
+ break;
+ } else{
+ /* In this case, the current protocol already has priority. Simply return. */
+ EPS_SAFE_RELEASE( printer->protocolInfo );
+ EPS_SAFE_RELEASE( printer );
+ EPS_RETURN( EPS_ERR_NONE )
+ }
+ }
+
+ if( NULL == current->next){
+ break;
+ }
+ current = current->next;
+ }
+
+ /* If we've reached this part of the code, it means we haven't found the printer. */
+ /* Time to add a new node to the list. */
+ /* The variable "current" is right now pointing to the last member of the list. */
+ if( !registered ){
+ /* Allocate a new printer on the end of the linked list. */
+ current->next = (EPS_PL_NODE*)EPS_ALLOC(sizeof(EPS_PL_NODE));
+ if(current->next == NULL) {
+ EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )
+ }
+
+ /* Fill in the list node. */
+ current->next->printer = printer;
+ current->next->next = NULL;
+ epsPrinterList.num++;
+
+ current = current->next;
+ }
+ }
+
+ EPS_DBGPRINT( ("Discover x%X (x%X) %s %s\n", printer->protocol, printer->supportFunc, printer->modelName, printer->printerID) )
+
+ if( TRUE == bNotify ){
+ MakePrinterStructure(&usrPrinter, printer);
+
+ if( EPS_USER_CANCEL == epsCmnFnc.findCallback(usrPrinter) ){
+ EPS_RETURN( EPS_FIND_CANCELED )
+ }
+ }
+
+ EPS_RETURN( EPS_ERR_NONE )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtIsRegistered() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* Address EPS_INT8* IP Address. */
+/* modelName EPS_INT8* Printer model name. */
+/* Protocol EPS_INT32 Protocol ID. */
+/* */
+/* Return value: */
+/* TRUE (registered), FALSE(not registered). */
+/* */
+/* Description: */
+/* Whether the printer has registered is confirmed. */
+/* */
+/*******************************************|********************************************/
+EPS_BOOL prtIsRegistered(
+
+ const EPS_INT8 *Address,
+ const EPS_INT8 *modelName,
+ EPS_INT32 Protocol
+
+){
+ EPS_PL_NODE* current = epsPrinterList.root;
+ EPS_BOOL bMatch = FALSE;
+
+ EPS_LOG_FUNCIN
+
+ while(NULL != current) {
+ /* If we've found a printer in the list that matches the module's printer, */
+ bMatch = FALSE;
+ if( 0 == strcmp(current->printer->location, Address) ){
+ if(NULL != modelName){
+ if( 0 == strcmp(current->printer->modelName, modelName) ){
+ bMatch = TRUE;
+ }
+ } else{
+ bMatch = TRUE;
+ }
+ }
+
+ if(TRUE == bMatch){
+ /* And the new protocol has priority over the old one... */
+ if (EPS_PRT_PROTOCOL(current->printer->protocol) <= EPS_PRT_PROTOCOL(Protocol)) {
+ EPS_RETURN( TRUE )
+ } else{
+ /* already registered However it's low level protocol */
+ EPS_RETURN( FALSE )
+ }
+ }
+
+ current = current->next;
+ }
+
+ EPS_RETURN( FALSE )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtAddUsrPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* usrPrinter EPS_PRINTER* I: User specified printer. */
+/* printer EPS_PRINTER* O: Internal printer information. */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success */
+/* EPS_ERR_INV_ARG_COMMMODE - Invalid argument "usrPrinter.protocol" */
+/* EPS_ERR_INV_ARG_PRINTER_ADDR - Invalid format " printer.location" */
+/* EPS_ERR_MEMORY_ALLOCATION - Fail to memory allocation */
+/* EPS_ERR_INV_PRINT_LANGUAGE - Invalid argument "usrPrinter.language" */
+/* */
+/* Description: */
+/* Register a user specified printer. */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtAddUsrPrinter(
+
+ const EPS_PRINTER* usrPrinter,
+ EPS_PRINTER_INN** printer
+
+){
+ EPS_ERR_CODE ret = EPS_ERR_NONE;
+ EPS_INT32 initProtocol = EPS_PRT_PROTOCOL(printJob.commMode);
+ EPS_INT32 tgtProtocol = EPS_PRT_PROTOCOL(usrPrinter->protocol);
+ EPS_INT8 address[EPS_ADDR_BUFFSIZE];
+ EPS_INT8* p = NULL;
+ EPS_INT32 nPort = 0;
+ EPS_PRINTER_INN* innerPrinter = NULL;
+
+ EPS_LOG_FUNCIN
+
+ *printer = NULL;
+
+ /*** Validate input parameters */
+ if( (tgtProtocol | initProtocol) != initProtocol){ /* Not Init protocol */
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ if( tgtProtocol & EPS_PROTOCOL_USB ){ /* USB */
+
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ if( memGetBitCount(tgtProtocol) > 1 ){ /* Multi protocol */
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ if( '\0' == usrPrinter->location[0] ){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ADDR )
+ }
+ if( EPS_ADDR_BUFFSIZE < strlen(usrPrinter->location) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ADDR )
+ }
+
+ if( !(EPS_LANG_ESCPR == usrPrinter->language ||
+#ifdef GCOMSW_CMD_ESCPAGE_S
+ EPS_LANG_ESCPAGE_S == usrPrinter->language ||
+#endif
+ EPS_LANG_ESCPAGE == usrPrinter->language ||
+ EPS_LANG_ESCPAGE_COLOR == usrPrinter->language ) ){
+ EPS_RETURN( EPS_ERR_INV_PRINT_LANGUAGE );
+ }
+
+ /*** pase location */
+ strcpy(address, usrPrinter->location);
+ p = strchr(address, ':');
+ if( NULL != p ){
+ *p = '\0';
+ p++; /* 1 = ':' */
+ sscanf(p, "%d", &nPort);
+ } else{
+ /* Default Port */
+ if( tgtProtocol & EPS_PROTOCOL_LPR ){
+#ifdef GCOMSW_PRT_USE_LPR
+ nPort = lprGetDefautiPort();
+#else
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+#endif
+ } else if( tgtProtocol & EPS_PROTOCOL_RAW ){
+#ifdef GCOMSW_PRT_USE_RAW
+ nPort = rawGetDefautiPort();
+#else
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+#endif
+ } else{
+ EPS_RETURN( EPS_ERR_INV_ARG_COMMMODE )
+ }
+ }
+ if( FALSE == IsValidAddress( address ) ){
+ EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ADDR )
+ }
+
+ /*** Create new printer */
+ innerPrinter = (EPS_PRINTER_INN*)EPS_ALLOC(sizeof(EPS_PRINTER_INN));
+ if( NULL == innerPrinter ){
+ EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )
+ }
+
+ memset(innerPrinter, 0x00, sizeof(EPS_PRINTER_INN));
+
+ strcpy(innerPrinter->location, address);
+ innerPrinter->printPort = (EPS_UINT16)nPort;
+ innerPrinter->protocol = usrPrinter->protocol;
+ innerPrinter->supportFunc = EPS_SPF_RGBPRINT | EPS_SPF_JPGPRINT;
+ innerPrinter->JpgMax = EPS_JPEG_SIZE_UNLIMIT;
+ innerPrinter->language = usrPrinter->language;
+ strcpy(innerPrinter->modelName, usrPrinter->modelName);
+ /* innerPrinter->manufacturerName */
+ /* innerPrinter->friendlyName */
+ /* innerPrinter->printerID; */
+ /* innerPrinter->protocolInfo; */
+
+ /*** Append to printer lsit */
+ ret = prtRegPrinter(innerPrinter, FALSE);
+ if( EPS_ERR_NONE == ret ){
+ *printer = innerPrinter;
+ }
+
+ EPS_RETURN( ret )
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtGetInnerPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer EPS_PRINTER Pointer to public infomation structure */
+/* */
+/* Return value: */
+/* EPS_PRINTER_INN Pointer to private infomation structure */
+/* */
+/* Description: */
+/* Get private infomation of printer. */
+/* */
+/*******************************************|********************************************/
+EPS_PRINTER_INN* prtGetInnerPrinter(
+
+ const EPS_PRINTER* printer
+
+){
+ EPS_PL_NODE* pCur = epsPrinterList.root;
+ EPS_PRINTER_INN* innerPrinter = NULL;
+
+ /* collates it with found printer */
+ while(NULL != pCur){
+ if(0 == strcmp(printer->modelName, pCur->printer->modelName)
+ && 0 == strcmp(printer->location, pCur->printer->location) ){
+ innerPrinter = pCur->printer;
+ break;
+ }
+ pCur = pCur->next;
+ }
+
+ return innerPrinter;
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtClearPrinterList() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* void */
+/* */
+/* Return value: */
+/* void */
+/* */
+/* Description: */
+/* Crean up inside list of printer structure . */
+/* */
+/*******************************************|********************************************/
+void prtClearPrinterList(
+
+ void
+
+){
+ EPS_PL_NODE* pCur = epsPrinterList.root;
+ EPS_PL_NODE* pNext = NULL;
+
+ EPS_LOG_FUNCIN
+
+ /* Clear stock printer list */
+ while(NULL != pCur){
+ pNext = pCur->next;
+
+ prtClearSupportedMedia(pCur->printer);
+
+ EPS_SAFE_RELEASE( pCur->printer->protocolInfo );
+ EPS_SAFE_RELEASE( pCur->printer );
+ EPS_SAFE_RELEASE( pCur );
+
+ pCur = pNext;
+ }
+
+ epsPrinterList.num = 0;
+ epsPrinterList.root = NULL;
+
+ EPS_RETURN_VOID
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtClearSupportedMedia() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer EPS_PRINTER_INN* I: Pointer to a printer info structure */
+/* */
+/* Return value: */
+/* void */
+/* */
+/* Description: */
+/* Crean up inside list of supported media structure. */
+/* */
+/*******************************************|********************************************/
+void prtClearSupportedMedia(
+
+ EPS_PRINTER_INN* printer
+
+){
+ EPS_INT32 idx;
+
+ EPS_LOG_FUNCIN
+
+ /* Clear "supportedMedia" */
+ if( NULL == printer ){
+ return;
+ }
+
+#ifdef GCOMSW_CMD_ESCPAGE
+ if(EPS_LANG_ESCPR == printer->language ){
+#endif
+ /*** ESC/P-R ***/
+ if( NULL != printer->supportedMedia.sizeList ){
+ for(idx = 0; idx < printer->supportedMedia.numSizes; idx++) {
+ EPS_SAFE_RELEASE(printer->supportedMedia.sizeList[idx].typeList);
+ }
+ EPS_SAFE_RELEASE(printer->supportedMedia.sizeList);
+ }
+#ifdef GCOMSW_CMD_ESCPAGE
+ } else{
+ /*** ESC/Page ***/
+ pageClearSupportedMedia(printer);
+ }
+#endif
+
+ printer->supportedMedia.numSizes = 0;
+ printer->supportedMedia.JpegSizeLimit = EPS_JPEG_SIZE_MAX; /* lowest guarantee */
+ printer->supportedMedia.resolution = EPS_IR_360X360;
+
+ EPS_RETURN_VOID
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtSetIdStr() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* printer EPS_PRINTER_INN* I/O: Pointer to a printer info structure */
+/* idString EPS_INT8* I: protocol depended unique string */
+/* */
+/* Return value: */
+/* void */
+/* */
+/* Description: */
+/* Set the Printer ID. */
+/* */
+/*******************************************|********************************************/
+void prtSetIdStr(
+
+ EPS_PRINTER_INN* printer,
+ const EPS_INT8* idString
+
+){
+ sprintf(printer->printerID, EPS_PRINTER_ID_STR,
+ EPS_PRT_PROTOCOL_EX(printer->protocol), idString);
+
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: prtRecoverPE() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* void - - */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Recovered successfully */
+/* EPS_ERR_COMM_ERROR - Recovery failed */
+/* */
+/* Description: */
+/* Tries to recover from the paper end error */
+/* */
+/*******************************************|********************************************/
+EPS_ERR_CODE prtRecoverPE (
+
+ void
+
+){
+ EPS_ERR_CODE ret;
+
+ EPS_LOG_FUNCIN
+
+ switch( EPS_PRT_PROTOCOL( printJob.printer->protocol ) ){
+#ifdef GCOMSW_PRT_USE_USB
+ case EPS_PROTOCOL_USB:
+ ret = usbMechCommand(EPS_CBTCOM_PE);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_LPR
+ case EPS_PROTOCOL_LPR:
+ ret = lprMechCommand(printJob.printer, EPS_CBTCOM_PE);
+ break;
+#endif
+
+#ifdef GCOMSW_PRT_USE_RAW
+ case EPS_PROTOCOL_RAW:
+ ret = rawMechCommand(printJob.printer, EPS_CBTCOM_PE);
+ break;
+#endif
+ default:
+ EPS_RETURN( EPS_ERR_NONE ) /* Other protocol Not Support recover command */
+ }
+
+ EPS_RETURN( ret )
+}
+
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
+/*-------------------- Local Functions ---------------------*/
+/*%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+#ifdef GCOMSW_PRT_USE_NETWORK
+/*******************************************|********************************************/
+/* */
+/* Function name: FindNetPrinter() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* protocol EPS_INT32 I: traget protocol */
+/* timeout EPS_UINT32 I: find timeout */
+/* plural EPS_BOOL I: TRUE= find plural printer / FALSE= one printer */
+/* address EPS_INT8* I: send discover message address. */
+/* (If plural=TRUE, this is NULL) */
+/* */
+/* Return value: */
+/* EPS_ERR_NONE - Success (Opened Communication) */
+/* EPS_ERR_MEMORY_ALLOCATION - Fail to memory allocation */
+/* EPS_ERR_PRINTER_NOT_FOUND - Printer not found (or error occur) */
+/* EPS_ERR_COMM_ERROR - socket error */
+/* */
+/* EPS_FIND_CANCELED - user discontinued it */
+/* */
+/* Description: */
+/* Find network printers. */
+/* */
+/*******************************************|********************************************/
+static EPS_ERR_CODE FindNetPrinter (
+
+ EPS_INT32 protocol,
+ EPS_UINT32 timeout,
+ EPS_BOOL plural,
+ const EPS_INT8* address
+
+){
+ EPS_ERR_CODE ret = EPS_ERR_PRINTER_NOT_FOUND; /* Return status of internal calls */
+ EPS_PRINTER_INN* innerPrinter = NULL;
+
+ EPS_FIND_FUNCS* pProtocolFncs = NULL;
+ EPS_FIND_FUNCS* pFncs = NULL;
+ EPS_UINT32 tmStart, tmNow, tmSpan, tmReq;
+ EPS_INT32 nProtocolCnt = 0;
+ EPS_INT32 nCnt = 0;
+ EPS_BOOL bBreak = FALSE;
+
+ EPS_LOG_FUNCIN
+
+ if(epsCmnFnc.getTime){
+ tmStart = epsCmnFnc.getTime();
+ tmNow = tmSpan = tmReq = 0;
+ } else{
+ timeout = tmStart = tmNow = tmSpan = tmReq = 0;
+ }
+
+#ifdef GCOMSW_PRT_USE_LPR
+ if(protocol & EPS_PROTOCOL_LPR) nProtocolCnt++;
+#endif
+#ifdef GCOMSW_PRT_USE_RAW
+ if( (protocol & EPS_PROTOCOL_RAW) && !(protocol & EPS_PROTOCOL_LPR) ) nProtocolCnt++;
+#endif
+ if(0 == nProtocolCnt){
+ EPS_RETURN( EPS_ERR_PRINTER_NOT_FOUND )
+ }
+
+ /* Setup net Find functions */
+ pProtocolFncs = (EPS_FIND_FUNCS*)EPS_ALLOC(sizeof(EPS_FIND_FUNCS)*nProtocolCnt);
+ if(NULL == pProtocolFncs){
+ EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )
+ }
+
+ pFncs = pProtocolFncs;
+
+#ifdef GCOMSW_PRT_USE_LPR
+ if(protocol & EPS_PROTOCOL_LPR){
+ pFncs->fncStart = &lprFindStart;
+ pFncs->fncCheck = &lprFind;
+ pFncs->fncEnd = &lprFindEnd;
+ pFncs->sock = EPS_INVALID_SOCKET;
+ if(plural){
+ strcpy(pFncs->address, EPSNET_UDP_BROADCAST_ADDR);
+ } else{
+ strcpy(pFncs->address, address);
+ }
+ pFncs++;
+ }
+#endif
+#ifdef GCOMSW_PRT_USE_RAW
+ if( (protocol & EPS_PROTOCOL_RAW) && !(protocol & EPS_PROTOCOL_LPR) ){
+ pFncs->fncStart = &rawFindStart;
+ pFncs->fncCheck = &rawFind;
+ pFncs->fncEnd = &rawFindEnd;
+ pFncs->sock = EPS_INVALID_SOCKET;
+ if(plural){
+ strcpy(pFncs->address, EPSNET_UDP_BROADCAST_ADDR);
+ } else{
+ strcpy(pFncs->address, address);
+ }
+ }
+#endif
+
+ /* Start (send discover message) */
+ pFncs = pProtocolFncs;
+ ret = EPS_ERR_NONE;
+ for(nCnt = 0; (nCnt < nProtocolCnt) && (ret == EPS_ERR_NONE); nCnt++, pFncs++){
+ ret = pFncs->fncStart( &(pFncs->sock), pFncs->address, plural );
+ }
+
+ /* Check response */
+ if( EPS_ERR_NONE == ret){
+ ret = EPS_ERR_PRINTER_NOT_FOUND;
+ }
+ while( (EPS_ERR_PRINTER_NOT_FOUND == ret || EPS_ERR_PRINTER_NOT_USEFUL == ret) && !bBreak ){
+ pFncs = pProtocolFncs;
+ for(nCnt = 0; nCnt < nProtocolCnt; ){
+ innerPrinter = NULL;
+ ret = pFncs->fncCheck(pFncs->sock, &innerPrinter);
+
+ if( EPS_COM_NOT_RECEIVE == ret ){
+ ret = EPS_ERR_PRINTER_NOT_FOUND;
+ } else{
+ tmReq = 0;
+ }
+
+ if( EPS_ERR_NONE == ret ){
+ innerPrinter->protocol |= EPS_PRT_DIRECTION(printJob.commMode);
+
+ ret = prtRegPrinter( innerPrinter, TRUE );
+
+ if(EPS_FIND_CANCELED == ret){
+ break;
+ } else if(FALSE == plural){
+ /* find one printer */
+ bBreak = TRUE;
+ break;
+ }
+
+ } else if(EPS_ERR_PRINTER_NOT_FOUND == ret ){
+ /* next protocol */
+ nCnt++;
+ pFncs++;
+ } else if(EPS_ERR_PRINTER_NOT_USEFUL == ret ){
+ if(FALSE == plural){
+ /* find one printer */
+ bBreak = TRUE;
+ break;
+ }
+ /* next protocol */
+ nCnt++;
+ pFncs++;
+ } else{
+ bBreak = TRUE;
+ break;
+ }
+ }
+ if(bBreak)break;
+
+ /* epsCancelFindPriter() */
+ if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
+ if( 0 == epsCmnFnc.lockSync() ){
+ if( g_FindBreak ){
+ epsCmnFnc.unlockSync();
+ bBreak = TRUE;
+ break;
+ }
+ epsCmnFnc.unlockSync();
+ }
+ }
+
+ /* Timeout */
+ if(timeout > 0){
+ tmNow = epsCmnFnc.getTime();
+ tmSpan = (EPS_UINT32)(tmNow - tmStart);
+ /*EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )*/
+ if( tmSpan >= timeout ){
+ bBreak = TRUE;
+ break;
+ }
+ }
+
+ /* re isuue request */
+ /*EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )*/
+ if( (EPS_ERR_PRINTER_NOT_FOUND == ret ||
+ EPS_ERR_PRINTER_NOT_USEFUL == ret) && epsCmnFnc.getTime )
+ {
+ tmNow = epsCmnFnc.getTime();
+ if( 0 == tmReq ){
+ tmReq = tmNow;
+ } else{
+ /* beef up */
+ if( EPSNET_FIND_REREQUEST_TIME <= (EPS_UINT32)(tmNow - tmReq) ){
+ EPS_DBGPRINT( ("beef up TM %u - %u <> %u\n", tmNow, tmReq, (EPS_UINT32)(tmNow - tmReq)) )
+ pFncs = pProtocolFncs;
+ ret = EPS_ERR_NONE;
+ for(nCnt = 0; (nCnt < nProtocolCnt) && (ret == EPS_ERR_NONE); nCnt++, pFncs++){
+ ret = pFncs->fncStart( &(pFncs->sock), pFncs->address, plural );
+ }
+ tmReq = 0;
+ if( EPS_ERR_NONE == ret){
+ ret = EPS_ERR_PRINTER_NOT_FOUND;
+ }
+ }
+
+ }
+ }
+ }
+
+ /* End */
+ pFncs = pProtocolFncs;
+ for(nCnt = 0; (nCnt < nProtocolCnt); nCnt++, pFncs++){
+ pFncs->fncEnd( pFncs->sock );
+ }
+
+ EPS_SAFE_RELEASE(pProtocolFncs);
+
+ EPS_RETURN( ret )
+}
+
+#endif /* GCOMSW_PRT_USE_NETWORK */
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: MakePrinterStructure() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* dst EPS_PRINTER* O: Printer information */
+/* src EPS_PRINTER_INN* I: Printer information internal */
+/* */
+/* Return value: */
+/* void */
+/* */
+/* Description: */
+/* Copy printer information. */
+/* */
+/*******************************************|********************************************/
+static void MakePrinterStructure(
+
+ EPS_PRINTER* dst,
+ EPS_PRINTER_INN* src
+
+){
+ EPS_DBGPRINT(("%s : %d\n", src->modelName, src->protocol))
+ dst->protocol = EPS_PRT_PROTOCOL(src->protocol);
+ dst->supportFunc = src->supportFunc;
+ dst->language = src->language;
+ strcpy(dst->location, src->location);
+ strcpy(dst->macAddress, src->macAddress);
+ strcpy(dst->manufacturerName, src->manufacturerName);
+ strcpy(dst->modelName, src->modelName);
+ strcpy(dst->friendlyName, src->friendlyName);
+ strcpy(dst->printerID, src->printerID);
+}
+
+
+/*******************************************|********************************************/
+/* */
+/* Function name: IsValidAddress() */
+/* */
+/* Arguments */
+/* --------- */
+/* Name: Type: Description: */
+/* addr EPS_INT8* I: IP Address */
+/* */
+/* Return value: */
+/* TRUE - valid */
+/* FALSE - invalid */
+/* */
+/* Description: */
+/* Validation of IP(v4) Address. */
+/* */
+/*******************************************|********************************************/
+static EPS_BOOL IsValidAddress(
+
+ const EPS_INT8* addr
+
+){
+#define EPS_IPSEGNUM (4)
+
+ EPS_UINT32 nSeg[EPS_IPSEGNUM];
+ EPS_INT16 nCnt;
+
+ memset(nSeg, 0xFF, sizeof(EPS_UINT32)*EPS_IPSEGNUM);
+
+ sscanf(addr, "%d.%d.%d.%d", &nSeg[0], &nSeg[1], &nSeg[2], &nSeg[3]);
+
+ for(nCnt = 0; nCnt < EPS_IPSEGNUM; nCnt++){
+ if(nSeg[nCnt] > 255){
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+/*________________________________ epson-protocol.c _________________________________*/
+
+/*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
+/* 1 2 3 4 5 6 7 8 */
+/*******************************************|********************************************/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+/***** End of File *** End of File *** End of File *** End of File *** End of File ******/
+/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
+
|