我的小工具-远程读卡器web客户端(PHP+LUA)

最新推荐文章于 2023-12-28 09:49:01 发布
最新推荐文章于 2023-12-28 09:49:01 发布
阅读量2.9k 收藏 4
点赞数 1
分类专栏： PHP 文章标签： python LUA 读卡器 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyz_1987/article/details/74418714
版权

   晚上睡不着，想着白天工作上的事，解决一个现场读卡问题就需要出趟差值得吗。想着在公司就能把现场的卡给读写诊断了，能让数据跑路就别让人跑路，说干就干。

本工具是在浏览器中以Lua脚本的形式对CPU卡,M1卡就行读、写等各种操作，配和使用改造过后的E711读卡器。

远端把读卡器接到电脑上，并运行读写卡服务。告知客户端IP地址和端口，并放上卡。客户端调用相关指令，运行脚本，输出结果。
    远程读卡器就是一个普通usb口或串口的读卡器，如E711读卡器。配合一个电脑软件作为tcp读写卡服务。这样可以在公司电脑上运行客户端程序连到服务器上,服务器端操控现场的读卡器。之前做保定公交老卡兼容，让现场寄卡过来，结果拖了好久，卡也没寄过来。说是卡片管理严格，老年卡，学生卡需要从系统上从新办卡。于是让现场同事配合抓下包，读取一下卡上数据，但现场同事连串口助手都没听说过，指望不上了。最后没办法，还是出差跑去一趟，做了些很简单的事。回来想想，其实可以做一个远程读卡器，在公司把现场的卡给操作了。再封装一些读卡的客户端接口，可以实现远程仿真调试程序读卡消费逻辑 ，或者实现一完全软件模拟的pos机。之前用java做过一个读写卡工具，但是只能在本地电脑上读写卡。

交通部卡测试消费成功的lua脚本指令：

--192.168.157.135/test3/runcode.php
--读卡服务地址
ip= "192.168.157.135"
--读卡服务端口
port = 5050

--连接到读卡服务
ret = CONNECT(ip,port)                     --建立连接
-------------------------------------------  CPU卡操作
ret,rcv = S_SFI("\x3F\x00",1)              --选择PSAM卡应用3F00
ret,rcv = R_BFile(0x15,0,0,1)              --读取PSAM卡15文件
ret,rcv = R_BFile(0x16,0,0,1)              --读取PSAM卡16文件
if ret == 0x9000 then
	PasmTID = string.sub(rcv,1,12)
	print("pasmTID:"..PasmTID)
end

ret,rcv = S_AID("\xA0\x00\x00\x06\x32\x01\x01\x05",0x08,0)      --选择交通部应用

ret,rcv = R_BFile(0x15,0,0,0)              --读取卡片0x15文件
if ret == 0x9000 then
	MakeCardId = string.sub(rcv,1,16)
	CardASN = string.sub(rcv,25,25+16-1)
	print(rcv)
	print("MakeCardId:"..MakeCardId)
	print("CardASN:"..CardASN)
end
ret,rcv = R_BFile(0x16,0,0,0)

ret,rcv = R_BFile(0x17,0,0,0)    

ret,rcv = S_SFI("\x80\x11",1)              --选择交通部PSAM卡应用

ret,rcv = APDU("805C030204",0)              --读取余额

--消费初始化
cmd = '805001020B'
index = '01'
money = '00000001'

cmdstr = cmd..index..money..PasmTID
print("xiao fei chu shi hua:")
ret,rcv = APDU(cmdstr,0)   --消费初始化
if ret == 0x9000 then
	PullCTC = string.sub(rcv,9,9+4-1)  --脱机交易序号
	KeyVer = string.sub(rcv,19,19+2-1)
	KeyDrk = string.sub(rcv,21,21+2-1)
	Icc =  string.sub(rcv,23,23+8-1)  --随机数
	print("PullCTC:"..PullCTC)
	print("KeyVer:"..KeyVer)
	print("KeyDrk:"..KeyDrk)
	print("Icc:"..Icc)
end

cmd = '8070000024'
time ='20161128170231'
cmdstr = cmd..Icc..PullCTC..money..'06'..time..KeyVer..KeyDrk..CardASN..MakeCardId 

ret,rcv = APDU(cmdstr,1)   --PSAM卡算MAC

if ret == 0x9000 then
	TTC = string.sub(rcv,1,8)  --脱机交易序号
	MAC1 = string.sub(rcv,9,9+8-1)
	print("TTC:"..TTC)
	print("MAC1:"..MAC1)
end

cmd = '805401000F'
cmdstr = cmd..TTC..time..MAC1

ret,rcv = APDU(cmdstr,0)

DISCONNECT()                --断开连接

    要远程读写卡得有个后台服务去操控远程的读卡器。有了后台读写卡服务，客户端不能只是接口，得简单好用，于是有了这个web端。

附截图：

截图1，运行效果

截图2，相关指令介绍：

截图3，后台文件

截图4，后台读写卡服务显示的收发日志：

后台的解析lua脚本的文件lua_test.c

//包含LUA的头文件，用来支持脚本
#include <stdio.h>
#include "lib/lua-5.3.1/lua.h"  
#include "lib/lua-5.3.1/lualib.h"  
#include "lib/lua-5.3.1/lauxlib.h"   

#include "lib/includes.h"

#define PICC_ADD                    0xC1            //加
#define PICC_SUB                    0xC0            //减
#define PICC_RESTORE                0xC2            //恢复

#define PICC_KEYA                   0x60            //KEY A
#define PICC_KEYB                   0x61            //KEY B

#define PICC_NULL                   0x00            //不校验KEY


lua_State* L;  

U08 gCardSN[8]; //物理卡号

U32 ICF_SelectAID( const char *AID, U32 ilen, U32 ich )
{
    U32 rcode;
    
    gCmdBuffer[0] = 0x00;   //CLA
    gCmdBuffer[1] = 0xA4;   //INS
    gCmdBuffer[2] = 0x04;   //P1
    gCmdBuffer[3] = 0x00;   //P2
    gCmdBuffer[4] = ilen;   //Lc
    CurCalc_DataCpy( gCmdBuffer+5, (U08*)AID, ilen );
    
    rcode = ICC_APDU_Exchange( ich, gCmdBuffer, ilen+5, gpRcvBuffer, &Grcv_Len, 260 );
    if( rcode != 0 )
    { return rcode; }
    
    if( Grcv_Len < 2 )  
    { return 2;}
    rcode = ( ( gpRcvBuffer[ Grcv_Len - 2 ] << 8 ) | gpRcvBuffer[ Grcv_Len - 1 ] );

    return rcode;

}
U32 ICF_SelectSFI( const char *SFI, U32 ich )
{
    U32 rcode;

    gCmdBuffer[0] = 0x00;   //CLA
    gCmdBuffer[1] = 0xA4;   //INS
    gCmdBuffer[2] = 0x00;   //P1
    gCmdBuffer[3] = 0x00;   //P2
    gCmdBuffer[4] = 0x02;   //Lc
    CurCalc_DataCpy( gCmdBuffer+5, (U08*)SFI, 2 );
    
    rcode = ICC_APDU_Exchange( ich, gCmdBuffer, 2+5, gpRcvBuffer, &Grcv_Len, 260 );
    if( rcode != 0 )
    { return rcode; }
    
    if( Grcv_Len < 2 )
    { return 2;}
    rcode = ( ( gpRcvBuffer[ Grcv_Len - 2 ] << 8 ) | gpRcvBuffer[ Grcv_Len - 1 ] );

    return rcode;
}
U32 ICF_ReadBinaryFile( U08 SFI, U08 Offset, U08 BytesToRead, U32 ich )
{
    unsigned short rcode;
    
    gCmdBuffer[0] = 0x00;   //CLA
    gCmdBuffer[1] = 0xB0;   //INS
    gCmdBuffer[2] = 0x80 | ( SFI & 0x1F );  //P1
    gCmdBuffer[3] = Offset; //P2
    gCmdBuffer[4] = BytesToRead;    //Le

    rcode = ICC_APDU_Exchange( ich, gCmdBuffer, 5, gpRcvBuffer, &Grcv_Len, 260 );
    if( rcode != 0 )
    { return rcode; }

    if( Grcv_Len < 2 )                                          //长度判断
    { return 2;}
    rcode = ( ( gpRcvBuffer[ Grcv_Len - 2 ] << 8 ) | gpRcvBuffer[ Grcv_Len - 1 ] );

    return rcode;
}

int LConnect(lua_State* L)
{
    int ret = 0;
    size_t le = 0;
    printf("Connecting...\n");
    const char * ipaddr = luaL_checklstring(L,1,&le);
    //printf("cmd is %s,le is %d\n",aid,le);  
    //从L栈中取出索引为2的数值，并检查  
    int port = luaL_checkinteger(L,2); 
    printf("ServerIP:%s,Port:%d\n", ipaddr,port);
    ret = Connect(ipaddr,port);
   
    lua_pushnumber(L,ret); 
    return 1;
}

int LDisConnect(lua_State* L)
{
    printf("Close connect!\n");
    Com_Dev_Disconnect( 0 );  
    return 1;
}

int LTxData(lua_State* L)
{
    int ret = 0;
    unsigned int len = 0;
    size_t le = 0;
    unsigned char buf[1024];
    unsigned char outbuf[2048];
    memset(buf, 0, 1024);
    memset(outbuf, 0, 2048);
    //从L栈中取出索引为1的数值，并检查  
    const char * txdata = luaL_checklstring(L,1,&le);
    //printf("tx is %s,le is %d\n",txdata,le);  
    StrToHex( (char*)txdata, le, buf );

    ret = Com_Dev_TxData( buf, le/2, 0, 0 );
	if( ret != 0 )
	{ DEF_SysCard_Debug; return ret; }
	
    ret = Com_Dev_RxData( buf, &len,  1024, 0, 0 ); 
	if( ret != 0 )
	{ DEF_SysCard_Debug; return ret; }

	HexToStr(buf,len,(char*)outbuf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)outbuf,strlen((char*)outbuf));
    return 2;

}

int LTxData1(lua_State* L)
{
    int ret = 0;
    unsigned int len = 0;
    size_t le = 0;
    unsigned char buf[1024];
    unsigned char outbuf[2048];
    memset(buf, 0, 1024);
    memset(outbuf, 0, 2048);
    //从L栈中取出索引为1的数值，并检查  
    const char * txdata = luaL_checklstring(L,1,&le);
   // printf("tx is %s,le is %d\n",txdata,le);  
    //StrToHex( (char*)txdata, le, buf );

    ret = Com_Dev_TxData1( (unsigned char*)txdata, le, 0, 0 );
	if( ret != 0 )
	{ DEF_SysCard_Debug; return ret; }
	
    ret = Com_Dev_RxData1( buf, &len,  1024, 0, 0 ); 
	if( ret != 0 )
	{ DEF_SysCard_Debug; return ret; }

	//HexToStr(buf,len,(char*)outbuf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf,len);
    return 2;

}
int LAPDU_Exchange(lua_State* L)
{
	int ret = 0;
 	size_t le = 0;
 	unsigned char buf[520];
	
	memset(buf, 0, 520);
 	//从L栈中取出索引为1的数值，并检查  
    const char * cmd = luaL_checklstring(L,1,&le);
    //printf("cmd is %s,le is %d\n",aid,le);  
    //从L栈中取出索引为2的数值，并检查  
    int ich = luaL_checkinteger(L,2); 

    StrToHex( (char*)cmd, le, gCmdBuffer );

    ret = ICC_APDU_Exchange( ich, gCmdBuffer, le/2, gpRcvBuffer, &Grcv_Len, 260 );
    if( Grcv_Len < 2)
	{ return 1;}

    ret = ( ( gpRcvBuffer[ Grcv_Len - 2 ] << 8 ) | gpRcvBuffer[ Grcv_Len - 1 ] );

    HexToStr(gpRcvBuffer,Grcv_Len,(char*)buf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf,strlen((char*)buf));
    return 2;
}
int LSelectAID(lua_State* L)
{
    int ret = 0;
    size_t le = 0;
    unsigned char buf[520];
    
    memset(buf, 0, 520);
    //从L栈中取出索引为1的数值，并检查  
    const char * aid = luaL_checklstring(L,1,&le);
    //printf("aid is %s,le is %d\n",aid,le);  
    //从L栈中取出索引为2的数值，并检查  
    int len = luaL_checkinteger(L,2); 
    int ich = luaL_checkinteger(L,3); 

    ret = ICF_SelectAID( aid, len, ich );
    HexToStr(gpRcvBuffer,Grcv_Len,(char*)buf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf,strlen((char*)buf));
    return 2;

}

int LSelectSFI(lua_State* L)
{
    int ret = 0;
    size_t le = 0;
    unsigned char buf[520];
    
    memset(buf, 0, 520);
    //从L栈中取出索引为1的数值，并检查  
    const char * sfi = luaL_checklstring(L,1,&le);
    //printf("aid is %s,le is %d\n",aid,le);  
    //从L栈中取出索引为2的数值，并检查  
    int ich = luaL_checkinteger(L,2); 

    ret = ICF_SelectSFI( sfi, ich );
    HexToStr(gpRcvBuffer,Grcv_Len,(char*)buf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf,strlen((char*)buf));
    return 2;

}
int LReadBinaryFile( lua_State* L )
{
    int ret = 0;
    unsigned char buf[520];
    
    memset(buf, 0, 520);
    //从L栈中取出索引为1的数值，并检查  
    int sfi =  luaL_checkinteger(L,1); 
    int oft =  luaL_checkinteger(L,2);
    int rlen = luaL_checkinteger(L,3);
    int ich =  luaL_checkinteger(L,4); 

    ret = ICF_ReadBinaryFile(sfi,oft,rlen,ich);

    HexToStr(gpRcvBuffer,Grcv_Len,(char*)buf);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf,strlen((char*)buf));

    //stackDump(L);
    return 2;
}
//获取CPU或M1卡的物理卡号
int LGetPhySn( lua_State* L )
{
    int ret = 0;
    unsigned char buf[20];
    unsigned char buf1[20];

    memset(buf,0,20);
    memset(buf1,0,20);

    ret = ICC_MiOne_GetPhySn(buf);

    memcpy(gCardSN,buf,8);//保存全局物理卡号

    HexToStr(buf,8,(char*)buf1);
    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)buf1,strlen((char*)buf1));
    //stackDump(L);
    return 2;
}
//M1卡扇区读
int LBlkRead( lua_State* L )
{
    int ret = 0;
    size_t le = 0;
    unsigned char rbuf[50];
    unsigned char sbuf[50];
    unsigned char key[16];
    unsigned char cmd=0;

    int block   =  luaL_checkinteger(L,1); 
    const char * keys = luaL_checklstring(L,2,&le);
    int keytype =  luaL_checkinteger(L,3); //密码类型,0,不校验 1,A码，2，B码

    memset(rbuf,0,50);
    memset(sbuf,0,50);
    StrToHex( (char*)keys, le, key );

    cmd = PICC_KEYA;
    if(keytype == 1)
    { cmd = PICC_KEYA; }
    else if(keytype == 2)
    { cmd = PICC_KEYB; }

    ret = ICC_MiOne_BlkRead(block,cmd,key, gCardSN, rbuf );

    HexToStr(rbuf,16,(char*)sbuf);

    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)sbuf,strlen((char*)sbuf));
    //stackDump(L);
    return 2;
}

//M1卡扇区写
int LBlkWrite( lua_State* L )
{
    int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char wbuf[50];
    unsigned char key[16];
    unsigned char cmd=0;

    int block   =  luaL_checkinteger(L,1); 
    const char * wbufs = luaL_checklstring(L,2,&le);
    const char * keys = luaL_checklstring(L,3,&le1);
    int keytype =  luaL_checkinteger(L,4); //密码类型,0,不校验 1,A码，2，B码

    memset(wbuf,0,50);

    StrToHex( (char*)wbufs, le, wbuf );
    StrToHex( (char*)keys, le1, key );

    cmd = PICC_KEYA;
    if(keytype == 1)
    { cmd = PICC_KEYA; }
    else if(keytype == 2)
    { cmd = PICC_KEYB; }

    ret = ICC_MiOne_BlkWrite(block,cmd,key, gCardSN, wbuf );

    lua_pushinteger(L,ret); 
    //stackDump(L);
    return 1;
}

//DES加密
int LDES_Encrypt( lua_State* L )
{
   // int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char inkey[16];
    unsigned char indata[16];
    unsigned char outdata[16];
	unsigned char str_out[50];
    const char * str_inkey = luaL_checklstring(L,1,&le);
    const char * str_indata = luaL_checklstring(L,2,&le1);

    StrToHex( (char*)str_inkey, le, inkey );
    StrToHex( (char*)str_indata, le1, indata );

	CurCalc_DES_Encrypt( inkey, indata, outdata );
	
	HexToStr(outdata,8,(char*)str_out);

    //lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)str_out,16);
    //stackDump(L);
    return 1;
}

//DES解密
int LDES_Decrypt( lua_State* L )
{
   // int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char inkey[16];
    unsigned char indata[16];
    unsigned char outdata[16];
	unsigned char str_out[50];
    const char * str_inkey = luaL_checklstring(L,1,&le);
    const char * str_indata = luaL_checklstring(L,2,&le1);

    StrToHex( (char*)str_inkey, le, inkey );
    StrToHex( (char*)str_indata, le1, indata );

	CurCalc_DES_Decrypt( inkey, indata, outdata );
	
	HexToStr(outdata,8,(char*)str_out);

    //lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)str_out,16);
    //stackDump(L);
    return 1;
}


//3DES加密
int LDES_3Encrypt( lua_State* L )
{
   // int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char inkey[16];
    unsigned char indata[16];
    unsigned char outdata[16];
	unsigned char str_out[50];
    const char * str_inkey = luaL_checklstring(L,1,&le);
    const char * str_indata = luaL_checklstring(L,2,&le1);

    StrToHex( (char*)str_inkey, le, inkey );
    StrToHex( (char*)str_indata, le1, indata );

	CurCalc_3DES_Encrypt( inkey, indata, outdata );
	
	HexToStr(outdata,16,(char*)str_out);

    //lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)str_out,32);
    //stackDump(L);
    return 1;
}

//3DES解密
int LDES_3Decrypt( lua_State* L )
{
   // int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char inkey[16];
    unsigned char indata[16];
    unsigned char outdata[16];
	unsigned char str_out[50];
    const char * str_inkey = luaL_checklstring(L,1,&le);
    const char * str_indata = luaL_checklstring(L,2,&le1);

    StrToHex( (char*)str_inkey, le, inkey );
    StrToHex( (char*)str_indata, le1, indata );

	CurCalc_3DES_Decrypt( inkey, indata, outdata );
	
	HexToStr(outdata,16,(char*)str_out);

    //lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)str_out,32);
    //stackDump(L);
    return 1;
}


U32 MathDesMac( U08 *pbuf, U32 length, U08 *key,U08 checktype )
{
	U32 len ;
	U08 mac[8], mac1[8];

	len = length ;

	if( checktype == 0 )
	{
		CurCalc_DES_MAC64( (SINGLE_DES_ENCRYPTION|ZERO_CBC_IV), key, 0, pbuf, len ,  mac );
		memcpy( pbuf+len, mac, 8 );
		return 0 ;
	}
	else
	{
		//暂存源校验码
		memcpy( mac1, pbuf+len-8, 8 ) ; 
		CurCalc_DES_MAC64( (SINGLE_DES_ENCRYPTION|ZERO_CBC_IV), key, 0, pbuf, len-8 ,  mac) ; 

		if ( memcmp( mac, mac1, 8 ) == 0x00 )
		{
			return 0 ;	 	//校验产生的校验码和原校验码相等, 校验成功
		}
		else
		{
			return 1 ;	  	//校验产生的校验码和原校验码不等, 校验失败
		}
	}	
}

int LMathDesMac( lua_State* L )
{
    int ret = 0;
    size_t le = 0,le1 =0;
    unsigned char inkey[16];
    unsigned char indata[1024];
	unsigned char str_out[2048];
    
    const char * str_indata = luaL_checklstring(L,1,&le);
	int   inlen   =  luaL_checkinteger(L,2);
	const char * str_inkey = luaL_checklstring(L,3,&le1);
	int   type   =   luaL_checkinteger(L,4);
    StrToHex( (char*)str_indata, le, indata );
	StrToHex( (char*)str_inkey, le1, inkey );

	ret = MathDesMac( indata, inlen,inkey,type );
	
	memset(str_out,0,2048);
	HexToStr(indata,inlen+8,(char*)str_out);

    lua_pushinteger(L,ret); 
    lua_pushlstring(L,(char*)str_out,strlen((char*)str_out));
    //stackDump(L);
    return 1;
}
int main( void )  
{  
    //初始化全局L  
    L = luaL_newstate();  //创建lua的栈 
    //打开库  
    luaL_openlibs(L);  
    //把函数压入栈中  
    //lua_pushcfunction(L, add);  
    //设置全局ADD  
    //lua_setglobal(L, "ADD");  
    //lua_register(L,"ADD",add);
    lua_pushcfunction(L, LConnect);  
    //设置全局ADD  
    lua_setglobal(L, "CONNECT"); 
    
    lua_register(L,"DISCONNECT", LDisConnect); 

    lua_register(L,"TxData",LTxData);
	lua_register(L,"TxData1",LTxData1);
	
    lua_register(L,"APDU", LAPDU_Exchange);  

    lua_register(L,"S_AID",LSelectAID); 
    lua_register(L,"S_SFI",LSelectSFI); 
    lua_register(L,"R_BFile",LReadBinaryFile);
    
    lua_register(L,"G_SN",LGetPhySn);
    lua_register(L,"R_Block",LBlkRead);
    lua_register(L,"W_Block",LBlkWrite);
	
	lua_register(L,"DES_Enc",LDES_Encrypt);
    lua_register(L,"DES_Dec",LDES_Decrypt);
	
	lua_register(L,"DES_3Enc",LDES_3Encrypt);
    lua_register(L,"DES_3Dec",LDES_3Decrypt);
	
	lua_register(L,"MathDesMac",LMathDesMac);
	
    //加载我们的lua脚本文件  
    if(luaL_loadfile(L,"test.lua"))  //载入lua脚本，是通过fopen打开的，
    {  
        printf("error,failed to analysis script!\nmaybe syntax error!\n");  
    }  
    //安全检查  
    lua_pcall(L,0,0,0); //这个函数会执行lua脚本 
    //push进lua函数  
   // lua_getglobal(L, "mylua1"); 
   // lua_pcall(L,0,0,0);   
    printf("end my lua script,finish!\n"); 
    lua_close(L); //关闭lua的栈  

    return 0;  
}


php后台的处理原理：

compile.php

<?php
header('Content-Type:json; charset=UTF-8');
set_time_limit(0);
//var_dump($_POST);
$str= $_POST['code'];
//echo $str;
file_put_contents("test.lua",$str);

$flv_cmd="lua_test.exe >out.txt";
exec($flv_cmd);

if(file_exists("out.txt"))
{
	$txt1 = file_get_contents("out.txt");
	$err ="ok";
	$txt =iconv("GB2312","UTF-8//IGNORE",$txt1); //将编码从GB2312转成UTF-8
	//echo $txt; 
}
else
{
	$txt ="output err!\n";
	$err ="exec err!\n";
}
$json = array("output"=>$txt,"langid"=>"17","code"=>"print(\"Hello World!\")","errors"=>$err,"time"=>"01\n");
//var_dump($json);
$result = json_encode($json);
//var_dump($result);
$output = $result;
echo $output; 
?>


后台库文件的makefile:

########################################
#makefile
########################################


#编译主程序
BINARY  := lua_test
OBJ_DIR := 
CC= gcc
LD= ld
CFLAGS= -std=c99 -Wall -g
LDSCRIPT= -lmycom -lws2_32 -liconv -lmyfile  -lmycard -lmyup -lmycalc -lmyblkfile -llua
LDFLAGS= -Llib 


SRC  = $(wildcard *.c)
DIR  = $(notdir $(SRC))
OBJS = $(patsubst %.c,$(OBJ_DIR)%.o,$(DIR))
#OBJS=  main.o myutils.o  inirw.o  cmdpboc.o cputest.o bustcp.o ansrec.o m1cmd.o m1api.o m1test.o upcash.o myother.o getsys.o
#CFLAGS=-std=c99
#@echo Building lib...
#$(call make_subdir)
.PHONY: clean lib
all:  prebuild  $(BINARY).exe


prebuild:
@echo Building app...


$(BINARY).exe : $(OBJS)
@echo Generating ...
$(CC) -o $(BINARY).exe $(OBJS) $(LDFLAGS) $(LDSCRIPT) 
@echo OK!


$(OBJ_DIR)%.o : %.c
$(CC) -c $(CFLAGS) $< -o  $@

clean:
rm -f $(OBJ_DIR)*.o
@echo Removed!

特立独行的猫a
关注
专栏目录
php控制rfid读卡器,RFID读卡器(125KHzRFID)
weixin_39736547的博客
03-24 522
【实例简介】125KHzRFID读卡器，stm8s003,IAR.【实例截图】【核心代码】STM8S_RFIDc├── 321.obc├── App│ ├── main.c│ ├── stm8s_conf.h│ ├── stm8s_it.c│ └── stm8s_it.h├── Bsp│ ├── bsp.c│ ├── bsp.h│ ├── bsp_adc.c│ ├─...
nginx+lua+redis通过匹配客户端ip进行灰度发布
06-29
nginx+lua+redis通过匹配客户端ip进行灰度发布 本文将讲述如何使用nginx、lua和redis来实现灰度发布，通过匹配客户端IP来实现灰度发布。灰度发布是一种常见的软件发布方式，它允许开发者在生产环境中发布新的版本，...
php实现读取和写读卡器,读取写入USB接口的读卡器源代码。
weixin_39577908的博客
03-23 672
usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Text;usingSystem.Windows.Forms;usingBLL;usingSystem.Runtime.InteropServices;usin...
IC卡读卡器调用php,IC卡读卡器如何进行IC卡的读卡？
weixin_36263314的博客
03-22 574
IC卡又称集成电路卡，它是在大小和普通信用卡相同的塑料卡片上嵌置一个或多个集成电路构成的。集成电路芯片可以是存储器或向处理器。带有存储器的IC卡又称为记忆卡或存储卡，带有微处理器的IC卡又称为智能卡或智慧卡。记忆卡可以存储大量信息；智能卡则不仅具有记忆能力，而且还具有处理信息的功能。IC卡是1974年一名法国新闻记者发明的。由于便于携带，存储量大，它日益受到人们的青睐。IC卡可以十分方便地存汽车费...
身份证阅读器 php的开发,编写php应用程序实现摘要式身份验证的方法详解
weixin_39680380的博客
03-10 210
通基本身份认证一样，也可以使用PHP网页处理HTTP请求报头字段来匹配摘要式身份验证信息。例如下边的代码使用header()函数要求客户端使用Digest验证，它在HTTP消息报头中增加了一个WWW-Authenticate字段：header('WWW-Authenticate:Digest Realm="MyRealm",nonce="47alf7cf25ce7",algorithm=MD5,q...
php 读卡,PHP读取网卡MAC地址
weixin_36452281的博客
03-10 137
PHP读取网卡MAC地址class GetMacAddr{var $return_array = array(); // 返回带有MAC地址的字串数组var $mac_addr;function GetMacAddr($os_type){switch ( strtolower($os_type) ){case "linux":$this->forLinux();break;case "sol...
lua-resty-dns-client:Lua DNS客户端，负载平衡器和实用程序库
05-01
Lua库包含一个dns客户端，几个实用程序和一个负载平衡器。 该模块目前仅适用于OpenResty，并建立在库的顶部 特征 解析A，AAAA，CNAME和SRV记录，包括端口 解析/etc/hosts 解析/resolv.conf并应用LOCALDOMAIN和RES_...
nginx+lua+redis 集群 连接插件和脚本
12-09
在构建高性能、高可用性的Web服务时，常常会利用到Nginx作为反向代理和负载均衡器，Lua作为扩展Nginx功能的脚本语言，而Redis则作为内存数据存储，提供快速的数据访问。本资源包“nginx+lua+redis集群 连接插件和...
lua-etcd-resty:OpenResty 的 etcd 客户端模块
07-09
2. **工具**：可能指的是用于编译或安装lua-etcd-resty的工具，例如luarocks，它是Lua的包管理器。 3. **httpcli-resty**：这是另一个OpenResty的Lua模块，用于执行HTTP请求。lua-etcd-resty依赖于它来发送RESTful...
魔兽世界插件-LUA编辑器 WOWLUA
05-24
WowLua 是一个在魔兽世界里边运行 Lua 脚本的编辑工具环境，他功能包括： 交互式 Lua 解释器 多页脚本编辑器。 语法着色 输出重定向到 WowLua 的输出窗口 WowLua 的输出窗口 /wowlua 或 /lua 打开 WowLua。 /...
D8 读卡器 D8 SDK 开发文档.zip
09-24
德卡D8开发文档 C#，JAVA，ocx，Python，Qt，VS，内有dll mode 代码；官网最全
读卡器读写程序 M1 D8
08-31
读卡器读写程序 M1 D8
MIFARE读写工具---D8M1
07-25
软件名：D8M1.exe 更新时间：2014.06.28 操作系统：windowAll 外部设备：D8读卡器 D8M1可以对MIFARE块读写操作，支持1K，4K。检验KEY后返回SAK，QTAQ，UID。基于D8读卡器提供的dcrf32.dll开发。
德卡D8开发工具
08-12
德卡公司D8读卡器的开发包，包含开发工具以及文档。
D8读卡软件免安装版
04-02
这款软件需配合D8读卡器来使用，功能强大，免驱动免安装，打开即用，非常方便。
php实现读写ic卡,diy用PIC单片机实现的IC卡读写器
weixin_30533109的博客
04-08 714
1.1 SPI主模式因为节制时钟SCK的输出，主模式可以在任何时辰开始传输数据。主模式通过软件协议节制从模式的数据输出。在主模式中，一旦SSPUF寄存器写入，数据就会发送或吸取。在吸取数据时，SSPSR寄存器凭证时钟速度移位，一旦吸取到一个字节，数据就传输到SSPBUF，同时刻断符号位和状态符号位置位。时钟的极性可以通过编程改变。在主模式中，时钟SCK的频率可以配置为：fosc/4(即Tcy)、f...
精伦身份证阅读器php_华视CVR-100身份证阅读器BS开发包
weixin_42131367的博客
02-05 1982
华视CVR-100身份证阅读器BS开发包、网页开发包版本：支持CVR-100U、CVR-100D下载地址：支持语言：支持ASP、ASPX、PHP、JSP、HTML等语言的WEB形式二次开发安装说明：运行CVRDLL.exe文件选择安装路径(安装路径需有读写权限)，点击安装。提示控件注册成功。注：win7下请以管理员方式运行CVRDLL.exe文件。(安装路径需有读写权限)安装路径下文件列表：(共8...
身份证阅读器web开发示例，支持JS/H5、React、Vue.js、jQuery、Node.js、AngularJS、TypeScript、Electron、JSP、PHP、ASP等语言开发
最新发布
广东东信智能科技有限公司的专栏
12-28 1897
1、最新适配支持了windows、Linux、安卓、国产系统（麒麟、统信）四大系统网页开发。3、支持身份证、社保卡、IC卡、银行卡、磁条卡等市场上常见卡类型读取识别。2、支持四种身份证类型读取。4、免驱安装，即插即用。
学习lua笔记分享(三)--C#远程加载lua代码
GaoHeShun的博客
07-03 770
.加载文件 Test01: --用递归实现阶乘 function Fac(n) if n<=1 then return n end return n* Fac(n-1) end Test02: --注意:1.加载文件时，保证两个文件在同一路径下 --2.require的特点是加载一次 -- a = require("Test01") -- print("require result=".
cocos2d-x+Lua快速开发游戏指南
"cocos2d-x+lua游戏开发教程概览" 本文主要介绍如何使用cocos2d-x游戏引擎结合Lua脚本语言进行游戏开发，包括环境搭建、基础使用、性能优势以及一系列相关主题。cocos2d-x提供对Lua的支持，使得开发者能够利用其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

特立独行的猫a

您的鼓励是我的创作动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值