Ejemplo n.º 1
0
/* update current status of printer */
void sig_usr1(int sig)
{
    char    prninfo[256]/*, status[32]*/;
    int isUsb;

    //fp=fopen("/etc/linuxigd/printer.log","w");

    memset( prninfo , 0 , sizeof(prninfo) );


    if (check_par_usb_prn() == TRUE) //uese USB when return TRUE
    {
	    //fputs( "INTERFACE=USB\n" , fp );
	    nvram_set("printer_ifname", "usb");
	    readUsbPrnID(prninfo);
	    isUsb = 1;
    }
    else
    {
	    // Goto this step, then printer must be turn on
	    //fputs( "INTERFACE=PAR\n" , fp );
	    nvram_set("printer_ifname", "par");
	    readParPrnID(prninfo);
	    isUsb = 0;
    }

    if (strcmp(prninfo, "  ")==0 || strlen(prninfo)==0)
    {
		//fprintf(fp, "MODEL=\"\"\n");
		nvram_set("printer_model_t", "");

		if (!isUsb)
		{
			/* Retry, only when paraport is plugged and no device id is returned */
			printf("Try again 2 seconds later\n");
			g_retry++;

			if (g_retry<MAX_GETID_RETRY) alarm(6);
			else g_retry = 0;
		}
    }
    else
    {
		//fprintf(fp, "MODEL=\"%s\"\n", prninfo);
		nvram_set("printer_model_t", prninfo);
    }

    /* update status of printer */
    if (nvram_invmatch("printer_model_t", ""))
    {
		readPrnStatus();
    }
    else
    {
		nvram_set("printer_status_t", "");
		nvram_set("printer_user_t", "");
    }
//    PRINT("Enter sig_usr1\n");	// nosiy...
}
Ejemplo n.º 2
0
void readPrnID(char *prninfo)
{
//    char    *token;

    if (check_par_usb_prn() == TRUE) //uese USB when return TRUE
    {
	readUsbPrnID(prninfo);
    }
    else
    {
	readParPrnID(prninfo);
    }
}
Ejemplo n.º 3
0
/*#######Lisa: Raw printing##########
 * open printer()
 * copy stream()
 * ProcessReq_Raw()
 ##################################*/
int open_printer(void)  
{
        int		f;

	check_par_usb_prn();
	if(g_useUsb==TRUE)
	{		
		if ((f=open("/dev/usb/lp0",O_RDWR)) < 0 ) 
		{
			syslog(LOGOPTS, "cannot open /dev/usb/lp0: %m\n");
			exit(1);
		}
	}
	else
	{
		if ((f=open("dev/lp0",O_RDWR)) < 0)
		{
//			syslog(LOGOPTS, "Open Parallel port error");
			exit(1);
		} 
	}
	return (f);
}
Ejemplo n.º 4
0
int Job_status( int *sock, char *input )
{
	char *s, *t, *name, *hash_key;
	int displayformat, status_lines = 0, i, n;
	struct line_list l, listv;
	struct line_list done_list;
	char error[SMALLBUFFER], buffer[16];
	int db, dbflag;
	
	FILE *READSTATUSFILE;//JY1120
	char readbuffer[SMALLBUFFER];//JY1120
	char *str_index;//JY1120

#if !defined(JYWENG20031104status)
	if( input && *input ) ++input;//JY1114
	if(get_queue_name(input))
	{
		printf("QueueName is not LPRServer\n");
		send_ack_packet(sock, ACK_FAIL);//JY1120
		return(0);
	}
	else
		printf("QueueName is LPRServer\n");

	int prnstatus=1;
	char buffertosend[LARGEBUFFER];
	int fdPRNPARorUSB=0;/*JYWENG20031104*/
	if((check_par_usb_prn())== 1)
		fdPRNPARorUSB=open("/dev/usb/lp0",O_RDWR);
	else
		fdPRNPARorUSB=open("/dev/lp0",O_RDWR);

	if(fdPRNPARorUSB == 0)
	{
		printf("file descriptor not created\n");
		send_ack_packet(sock, ACK_FAIL);//JY1120
		return(0);	
	}
//	ioctl(fdPRNPARorUSB, 0x060b, &prnstatus);
//	if(prnstatus == 0)
//JY1120
	if((READSTATUSFILE=fopen("/var/state/printstatus.txt", "r")) == NULL)
	{
		printf("open /var/state/printstatus.txt failed!\n");
		send_ack_packet(sock, ACK_FAIL);//JY1120
		return(0);		
	}
	while( fgets(readbuffer, SMALLBUFFER, READSTATUSFILE) != NULL)
	{
		if((str_index = strstr(readbuffer, "PRINTER_STATUS=\"")))
		{
			str_index += 16;//moving to status
			strncpy(printerstatus, str_index, strlen(str_index) - 2 );	
		}
	}
//JY1120	

	SNPRINTF(buffertosend, sizeof(buffertosend))"Status: %s\n", printerstatus);
//	else
//		SNPRINTF(buffertosend, sizeof(buffertosend))"Status: Off line\n");
//	if( Write_fd_str( *sock, buffertosend ) < 0 ) cleanup(0);
	if( write( *sock, buffertosend, strlen(buffertosend) ) < 0 ) cleanup(0);
	exit(0);//JY1120
	
#endif


#ifdef REMOVE
	Init_line_list(&l);
	Init_line_list(&listv);
	Init_line_list(&done_list);
	db = Debug;
	dbflag = DbgFlag;

	Name = "Job_status";

	/* get the format */
	if( (s = safestrchr(input, '\n' )) ) *s = 0;
	displayformat = *input++;

	/*
	 * if we get a short/long request from these hosts,
	 * reverse the sense of question
	 */
	if( Reverse_lpq_status_DYN
		&& (displayformat == REQ_DSHORT || displayformat==REQ_DLONG)  ){
		Free_line_list(&l);
		Split(&l,Reverse_lpq_status_DYN,File_sep,0,0,0,0,0,0);
		if( Match_ipaddr_value( &l, &RemoteHost_IP ) == 0 ){
			DEBUGF(DLPQ1)("Job_status: reversing status sense");
			if( displayformat == REQ_DSHORT ){
				displayformat = REQ_DLONG;
			} else {
				displayformat = REQ_DSHORT;
			}
		}
		Free_line_list(&l);
	}
	/*
	 * we have a list of hosts with format of the form:
	 *  Key=list; Key=list;...
	 *  key is s for short, l for long
	 */
	DEBUGF(DLPQ1)("Job_status: Force_lpq_status_DYN '%s'", Force_lpq_status_DYN);
	if( Force_lpq_status_DYN ){
		Free_line_list(&listv);
		Split(&listv,Force_lpq_status_DYN,";",0,0,0,0,0,0);
		for(i = 0; i < listv.count; ++i ){
			s = listv.list[i];
			if( (t = safestrpbrk(s,File_sep)) ) *t++ = 0;
			Free_line_list(&l);
			Split(&l,t,Value_sep,0,0,0,0,0,0);
			DEBUGF(DLPQ1)("Job_status: Force_lpq_status '%s'='%s'", s,t);
			if( Match_ipaddr_value( &l, &RemoteHost_IP ) == 0 ){
				DEBUGF(DLPQ1)("Job_status: forcing status '%s'", s);
				if( safestrcasecmp(s,"s") == 0 ){
					displayformat = REQ_DSHORT;
				} else if( safestrcasecmp(s,"l") == 0 ){
					displayformat = REQ_DLONG;
				}
				status_lines = Short_status_length_DYN;
				break;
			}
		}
		Free_line_list(&l);
		Free_line_list(&listv);
	}

	/*
	 * check for short status to be returned
	 */

	if( Return_short_status_DYN && displayformat == REQ_DLONG ){
		Free_line_list(&l);
		Split(&l,Return_short_status_DYN,File_sep,0,0,0,0,0,0);
		if( Match_ipaddr_value( &l, &RemoteHost_IP ) == 0 ){
			status_lines = Short_status_length_DYN;
			DEBUGF(DLPQ1)("Job_status: truncating status to %d",
				status_lines);
		}
		Free_line_list(&l);
	}

	DEBUGF(DLPQ1)("Job_status: doing '%s'", input );
	Free_line_list(&l);
	Split(&l,input,Whitespace,0,0,0,0,0,0);
	if( l.count == 0 ){
		SNPRINTF( error, sizeof(error)) "zero length command line");
		goto error;
	}
Ejemplo n.º 5
0
int processReq(int sockfd)
{
    
    char                recv_buf[4]; //buffer to receive header
    static char         waittime = 1;
    int                 iCount;
    struct print_buffer pbuf;
    char                chPortOpened = FALSE;
    
    /***************************************/
    /**  We reset the printer only when   **/
    /**  user wants to cancel a job or    **/
    /**  error occurs                     **/
    /***************************************/
    
    //Process the request from cleint 
    //return when error or job complete
    while(TRUE)
    {
        LPT_CMD_PKT_HDR     *pHdrCmd  = NULL;
        LPT_DATA_PKT_HDR    *pHdrData = NULL;
        LPT_RES_PKT_HDR     pktRes;
        WORD                body[1];
        int                 rcv; //records how many bytes being received
        char                *para_buf = NULL; //buffer to store parameter
        
        memset(recv_buf,0,sizeof(recv_buf));
        iCount = sizeof(recv_buf);

        if(waittime < 5)
        {
            waittime ++;
        }

        //Receive the complete header here
        while( iCount > 0 )
        {
            rcv = RECV(sockfd , recv_buf + (4 - iCount) , iCount , 60);

            if( rcv < 1)
            {
                //receive error
                //PRINT("1. rcv -> %d\n",rcv);

                if(rcv < 0)
                {
                	//perror("ERR:");             
                }
                
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                
                return 0;
            }
            
            iCount = iCount - rcv;
        }


        //Check Service ID

        switch(recv_buf[0])
        {
            case NET_SERVICE_ID_LPT_EMU:
                //PRINT("Service ID -> NET_SERVICE_ID_LPT_EMU \n");
                break;
            
            default:
                //PRINT("Service ID -> Not Supported \n");
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                return(0);
                break;
        }


        //Check Packet Type

        switch(recv_buf[1])
        {
            case NET_PACKET_TYPE_CMD:
                //PRINT(">>> TYPE_CMD ");
                pHdrCmd = (LPT_CMD_PKT_HDR *)recv_buf;
                break;
            
            case NET_PACKET_TYPE_RES:
                //We should not recevice Response Packet in Server
                //PRINT("Packet Type -> NET_PACKET_TYPE_RES Error!!! \n");
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                return(0);
                break;
            
            case NET_PACKET_TYPE_DATA:
                //PRINT("$$$ TYPE_DATA ");
                pHdrData = (LPT_DATA_PKT_HDR *)recv_buf;
                break;
            
            default:
                //PRINT("Packet Type -> Not Supported \n");
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                return(0);
                break;
        
        }

        if( pHdrCmd != NULL) 
        {
            //We receive command
            
            para_buf = NULL;

            iCount = pHdrCmd->ParaLength;

	    if (iCount!=0)
	    {
             	para_buf = (char *)malloc(pHdrCmd->ParaLength);
            }

	    //PRINT("HdrCmd Length %d\n", iCount);

	    // para_buf may be NULL but this command still work
	    // 2004/06/07 by Joey
            if(iCount!=0 && para_buf == NULL)
            {
                //perror("malloc error 1:");
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                return(0);
            }

            while( iCount > 0 )
            {
                rcv = RECV(sockfd , (para_buf + (pHdrCmd->ParaLength - iCount )) , iCount , 30);

                if( rcv < 1)
                {
                    //receive error
                    //perror("2. RECV ERR:");             
                    closesocket(sockfd);
                    free(para_buf);
                    if(chPortOpened == TRUE)
                    {
                        reset_printer(10);
                    }
                    return 0;
                }
                
                iCount = iCount - rcv;
            }


            switch(pHdrCmd->CommandID)
            {
                case NET_CMD_ID_OPEN:
                    //remark PRINT("NET_CMD_ID_OPEN\n"); 
                                                                                                
                    /************************************/
                    /************************************/
                    /*** TODO: add code here to check ***/
                    /*** the printer status           ***/
                    /************************************/
                    /************************************/

                    pktRes.ServiceID = NET_SERVICE_ID_LPT_EMU;
                    pktRes.PacketType = NET_PACKET_TYPE_RES;
                    pktRes.CommandID = NET_CMD_ID_OPEN;
                    pktRes.ResLength = 2;

                    if(busy == FALSE)
                    {
                        int prnstatus=0;
		        FILE *statusFp = NULL;
                        
                        
                        //remark PRINT("--------lptstatus.busy == FALSE\n"); 
                        
                        /* add by James Yeh to support usb printer */
                        /* 2002/12/25 							   */
                        
                        
                        check_par_usb_prn();
                        
                        //Open printer port -modified by PaN
                        if(g_useUsb == TRUE)
                        {
                        	fdPRN = open("/dev/usb/lp0",O_RDWR);
                        }
                        else
                        {
                        	fdPRN = open("/dev/lp0",O_RDWR);
                        }

                        if(fdPRN == 0)
                        {
                            //Failed to open printer port
                            //PRINT("Can not open lp0 errno -> %d \n",errno);
                            //perror("ERR:");
    
                            //Send header
                            send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);
                            //Send body
                            body[0] = ERR_SERVER_LPT_FAIL;
                            send(sockfd , body , sizeof(body) , 0);
                            free(para_buf);
                            return(0);
                        }
                        
                        ioctl(fdPRN,LPGETSTATUS,&prnstatus);
                        
                        if(prnstatus != 0)
                        {
                            //remark PRINT("prnstatus != 0\n"); 
                            body[0] = ERR_SERVER_OCCUPIED;
                            
                            /*******************************************************************************/
                            /* why we are using ERR_SERVER_OCCUPIED instead of ERR_SERVER_LPT_FAIL here ?? */
                            /* Because ERR_SERVER_OCCUPIED will let user try again & again. Using          */
                            /* ERR_SERVER_LPT_FAIL will fail the reques                                    */
                            /*******************************************************************************/
    
                            //Send header
                            send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);
                            //Send body 
                            send(sockfd , body , sizeof(body) , 0);
                            free(para_buf);
                            return(0);
                        }
                        
			            statusFp = fopen(STATUS_FILE , "w");
            
            			if(statusFp != NULL)
            			{
                			fprintf(statusFp,"PRN_CLIENT=\"%s\"\n",lptstatus.addr);
                			fclose(statusFp);
            			}
            			else
            			{
                			//perror("Open status file failed: ");
            			}

                        chPortOpened = TRUE;
                        
                        body[0] = ERR_SUCCESS;
                    }
                    else
                    {
                        //PRINT("*********lptstatus.busy == TRUE\n");
                        body[0] = ERR_SERVER_OCCUPIED;

                        //Send header
                        send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);
                        //Send body 
                        send(sockfd , body , sizeof(body) , 0);
                        free(para_buf);
                        return(0);
                    }

                    //Send header
                    send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);
                    //Send body 
                    send(sockfd , body , sizeof(body) , 0);

                    break;

                case NET_CMD_ID_CLOSE:
                {
                    char bCancel = FALSE;
                    
                     
                    //remark PRINT("NET_CMD_ID_CLOSE\n");

                    /*****************************************************/
                    /* Check if user normally or abnormally end this job */
                    /*                                 James 2002/06/05  */
                    /*****************************************************/
                    
                    if(pHdrCmd->ParaLength != 1) //Length should be 1 byte long
                    {
                        //remark PRINT("NET_CMD_ID_CLOSE length error -- %d\n",pHdrCmd->ParaLength);
                        closesocket(sockfd);
                        free(para_buf);
                        if(chPortOpened == TRUE)
                        {
                            reset_printer(10);
                        }
                        return(0);
                    }
                    
                    //remark PRINT("para_buf[0] - %02X\n",para_buf[0]); 
                    
                    if(para_buf[0] == 1)
                    {
                        bCancel = TRUE;
                    }
                    

                    pktRes.ServiceID = NET_SERVICE_ID_LPT_EMU;
                    pktRes.PacketType = NET_PACKET_TYPE_RES;
                    pktRes.CommandID = NET_CMD_ID_CLOSE;
                    pktRes.ResLength = 2;

                
                    //Send header
                    send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);

                    //Send body 
                    body[0] = ERR_SUCCESS;
                    send(sockfd , body , sizeof(body) , 0);

                    closesocket(sockfd);
                    free(para_buf);
                    
                    //close printer port modified by PaN
                    sleep(1);

                    if(bCancel == TRUE)
                    {
                        //reset printer
                        //PRINT("Reset Printer\n");
                        reset_printer(10);
                    }

                    close(fdPRN); 

                    return(0);                              
                    break;
                }//case NET_CMD_ID_CLOSE:
                    
                case NET_CMD_ID_READ:
                {
                    LPT_DATA_PKT_HDR    pktData;
                    WORD                len;
                    int                 res_fread = 0;
                    PBYTE               pReadbuf;

                    len = (para_buf[1] << 8) + para_buf[0];
                    
                    //remark PRINT("NET_CMD_ID_READ len -> %d\n",len);

                    /************************************/
                    /************************************/
                    /*** TODO: add code here to read  ***/
                    /*** the printer port             ***/
                    /************************************/
                    /************************************/
                    
                    pReadbuf = (char *)malloc(len + 1);
                    
                    if(pReadbuf == NULL)
                    {
                        //perror("malloc error 2:");
                        closesocket(sockfd);
                        free(para_buf);
                        if(chPortOpened == TRUE)
                        {
                            reset_printer(10);
                        }
                        return(0);
                    }
                    
                    pbuf.len = len;
                    pbuf.buf = pReadbuf;
                    //PRINT("Start Read\n");
                    res_fread = ioctl(fdPRN,LPREADDATA,&pbuf);
                    //PRINT("End Read\n");
                    //PRINT("---- res_fread %d\n",res_fread);
                    
                    if(res_fread > 0)
                    {
                        len = res_fread;
                        pReadbuf[res_fread]= 0;
                        //PRINT("*** %s\n",pReadbuf);
                    }
                    else
                    {
                        len = 0;
                    }

                    pktData.ServiceID = NET_SERVICE_ID_LPT_EMU;
                    pktData.PacketType = NET_PACKET_TYPE_DATA;
                    pktData.DataLength = len; //can not exceed 0xFFFF

                    /**********    Sending Header     **********/
                    send(sockfd , (const char *)&pktData , sizeof(pktData) , 0);
                
                    if( len > 0)
                    {
                        /**********    Sending Body       **********/
                        send(sockfd , (const char *)pReadbuf , len , 0);
                    }
                    free(pReadbuf);                     
                    
                    break;
                }

                free(para_buf);
            }//switch(pHdrCmd->CommandID)
        }//if( pHdrCmd != NULL) 


        if( pHdrData != NULL) 
        {
            //We receive Data
            int     res_fwrite;
            int     res_total_fwrite;
            int     write_len;
            int     total_len;
            PBYTE   write_buf;
            int prnstatus=0;

            iCount = pHdrData->DataLength;

            if (iCount!=0)
	    {
            	para_buf = (char *)malloc(pHdrData->DataLength);
            }
            //remark 
	    //PRINT("pHdrData->DataLength -- %d\n",pHdrData->DataLength);

            if(iCount!=0 && para_buf == NULL)
            {
                //perror("malloc error 3:");
                closesocket(sockfd);
                if(chPortOpened == TRUE)
                {
                    reset_printer(10);
                }
                return(0);
            }
            
            //PRINT("DATA HDR OK...\n");

            while( iCount > 0 )
            {
                rcv = RECV(sockfd , (para_buf + (pHdrData->DataLength - iCount )) , iCount , 30);

                if( rcv < 1)
                {
                    //receive error
                    //perror("3. RECV ERR:");             
                    closesocket(sockfd);
                    free(para_buf);
                    if(chPortOpened == TRUE)
                    {
                        reset_printer(10);
                    }
                    return 0;
                }

                iCount = iCount - rcv;
            }


            //PRINT("DATA BODY OK...\n");

            pbuf.len = pHdrData->DataLength;
            pbuf.buf = para_buf;
            
            write_len = 0;
            total_len = pHdrData->DataLength;
            write_buf = para_buf;
            res_fwrite = 0;
            res_total_fwrite = 0;
            
            //remark PRINT("total_len %d\n",total_len);
            
            while(total_len > 0)
            {
                if(total_len > 4096)
                {
                    pbuf.len = 4096;
                    pbuf.buf = write_buf;
                    res_fwrite = ioctl(fdPRN,LPWRITEDATA,&pbuf);

                    if(res_fwrite != 4096)
                    {
                        DWORD retry = 0;
                        
                        ioctl(fdPRN,LPGETSTATUS,&prnstatus);
                        
                        //remark PRINT("prnstatus %d\n",prnstatus);

                        while( ((prnstatus == 0) || (prnstatus & LP_PBUSY)) && (res_fwrite != 4096) && (retry < 3))
                        {
                            //remark PRINT("}}}}}}}}}}}} res_fwrite %d\n",res_fwrite);
                            pbuf.len = 4096 - res_fwrite;
                            pbuf.buf = &(write_buf[res_fwrite]);
                            //usleep(500); //why we don't use usleep here ?? becuse usleep will sleep longer then we expect in iBox
                            sleep(1);
                            res_fwrite = res_fwrite + ioctl(fdPRN,LPWRITEDATA,&pbuf);
                            //remark PRINT("}}}}}}}}}}}} res_fwrite %d\n",res_fwrite);
                            ioctl(fdPRN,LPGETSTATUS,&prnstatus);

                            //remark PRINT("retry %d\n",retry);
                            retry ++;   
                        }
                        
                    }
                    
                    res_total_fwrite = res_total_fwrite + res_fwrite;
                    
                    if(res_fwrite != 4096)
                    {
                        break;
                    }
                    else
                    {
                        total_len = total_len - 4096;
                        if(total_len == 0)
                        {
                            //remark PRINT("total_len == 0 \n");
                            break;
                        }
                        write_buf = &(write_buf[4096]);
                    }

                    //remark PRINT("res_total_fwrite %d -- res_fwrite %d \n",res_total_fwrite,res_fwrite);
                    
                }
                else
                {
                    pbuf.len = total_len;
                    pbuf.buf = write_buf;
                    res_fwrite = ioctl(fdPRN,LPWRITEDATA,&pbuf);

                    //remark PRINT("PPPPPPP res_fwrite %d\n",res_fwrite);
                    if(res_fwrite != total_len)
                    {
                        DWORD retry = 0;

                        ioctl(fdPRN,LPGETSTATUS,&prnstatus);
                        //remark PRINT("prnstatus %d\n",prnstatus);
                        
                        while( ((prnstatus == 0) || (prnstatus & LP_PBUSY))  && (res_fwrite != total_len) && (retry < 3))
                        {
                            pbuf.len = total_len - res_fwrite;
                            pbuf.buf = &(write_buf[res_fwrite]);
                            //usleep(500); //why we don't use usleep here ?? becuse usleep will sleep longer then we expect in iBox
                            sleep(1);
                            res_fwrite = res_fwrite + ioctl(fdPRN,LPWRITEDATA,&pbuf);
                            //remark PRINT("}}}}}}}}}}}} res_fwrite %d\n",res_fwrite);
                            ioctl(fdPRN,LPGETSTATUS,&prnstatus);
                            //remark PRINT("retry %d\n",retry);
                            retry ++;   
                        }
                        
                    }

                    res_total_fwrite = res_total_fwrite + res_fwrite;
                    //remark PRINT("res_total_fwrite %d -- res_fwrite %d \n",res_total_fwrite,res_fwrite);
                    break;
                }
                
            }
                
                
            //remark PRINT("WritePrint %d - %d bytes\n",res_total_fwrite,pHdrData->DataLength);

            if(res_total_fwrite != pHdrData->DataLength)
            {
                int tmp=0;
                //remark PRINT("res_total_fwrite != pHdrData->DataLength \n");
                ioctl(fdPRN,LPGETSTATUS,&prnstatus);
                
                //remark PRINT("prnstatus %08X \n",prnstatus);
                
                if((prnstatus & LP_PERRORP) == 1 ) //Printer off-line
                {
                    //remark PRINT("Printer off-line -- prnstatus %d\n",prnstatus);
                    res_total_fwrite = res_total_fwrite|0x8000;
                }
                else
                {
                    //remark PRINT("Paper Empty -- prnstatus %d\n",prnstatus);
                    res_total_fwrite = res_total_fwrite|0x4000;
                }
		check_prn_status("BUSY or ERROR", clientaddr);
            }
            else{//JY1113 add
/*JY1113*/
		check_prn_status("Printing", clientaddr);
/**/
            }
            //remark PRINT("res_total_fwrite %08X\n",res_total_fwrite);

            body[0] = res_total_fwrite;

            pktRes.ServiceID = NET_SERVICE_ID_LPT_EMU;
            pktRes.PacketType = NET_PACKET_TYPE_RES;
            pktRes.CommandID = NET_CMD_ID_DATA_RES;
            pktRes.ResLength = 2;

            //Send header
            send(sockfd , (const char *)&pktRes , sizeof(pktRes) , 0);

            //Send body 
            send(sockfd , body , sizeof(body) , 0);
 
            free(para_buf);
        }//if( pHdrData != NULL) 
    }
    //remark PRINT("Thread Over\n");

    return(0);                              
    
}