bms_host.c

UNIX/LINUX平台下面SMS网管原代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>

#include "apgloble.h"
#include "bms_micro.h"
#include "etc.h"
#include "api20.h"

extern char etcfile[128];
extern char Host_Ip[ 20 + 1] ;
extern int  Host_Port ;

/* Local function */
static int GetValueFromBigStruct(char *value, char *fieldno, BIG_STRC *bs);
static int SetValueToBigStruct(BIG_STRC *bs, char *fieldno, char *value);
static int GetErrorCode(char *buff, char *errcode);
static int GetTxCode(char *bank, int sunyard);
static void pub_get_yearsecond(char *str) ;
int UnPack(BIG_STRC *bs, char *buf);
int ProduceFile(char *packet, BIG_STRC *bs);
static int GetTotalLines(int *lines, char *buffer, char *field);
static int Pack_Head( char *p, BIG_STRC *bs, char *hostcode);
static int PackBody(char *buffer,char *sendbuf, BIG_STRC *bs);
int Process_Host_Err( char *code, short *result );

/* Globle function */
int CallHost(BIG_STRC *bs);

/*
 * function	: CallHost		
 */
int CallHost(BIG_STRC *bs)
{
	char sendbuf[20480];
	char buffer[64 + 1];
	char recvbuff[20480];
	char txcode[6 + 1]; 
	short ctype = 0 ; 
	int flag;
	int rLen = 0;


	memset(sendbuf, 0, sizeof(sendbuf));
	memset(recvbuff, 0, sizeof(recvbuff));
	memset(buffer, 0, sizeof(buffer));
	memset(txcode, 0, sizeof(txcode));
	
	dp.sn = 0;

	bms_trace("Process [%d]...", bs->optcode);

	if(GetTxCode(txcode, bs->optcode) == FAILURE)
	{
		bs->result = HOST_TRADE_STOP ;
		return( FAILURE) ;
	}
	bms_trace("txcode[%s]",txcode);
        if(Pack_Head(buffer, bs, txcode) == FAILURE)
        {
                bs->result = PACK_HEAD_ERROR;
                return FAILURE;
        }
        if(PackBody(buffer,sendbuf, bs) == FAILURE)
        {
                bs->result = PACK_BODY_ERROR;
                return FAILURE;
        }
        bms_trace("PackBody %d",bs->optcode);

	bms_trace("exchanging data with server...");
        memset(recvbuff, 0, sizeof(recvbuff));

        if(CommHost(recvbuff, &rLen, sendbuf, strlen(sendbuf)) != SUCCESS )
        {
                bs->result = 1406;
                return( FAILURE) ;
        }

	if(UnPack(bs, recvbuff) != SUCCESS) return FAILURE;

	return(SUCCESS);
}

static int Pack_Head( char *p, BIG_STRC *bs, char *hostcode)
{ 
	char tmp[64 + 1];
	char bitmaps[512];
	char key[64];

	memset(bitmaps, '\0', sizeof(bitmaps));
        memset(key, 0, sizeof(key));
	memset(tmp, 0, sizeof(tmp));

	sprintf(tmp,"%04s%04s0100012401240000T0101",hostcode,hostcode);	//
	
	strcpy(p, tmp);

	return( SUCCESS) ;
}

/*
 * function	: PackBody
 * input	: optcode, BIG_STRC
 *		: SUCCESS / FAILURE
 */
static int PackBody(char *buf,char *sendbuf, BIG_STRC *bs)
{
	char key[64];
	char bitmaps[512], TotalItem[7 + 1];
	char host_field[6 + 1], bs_field[3 + 1],len_field[3 + 1];
	char buffer[128];
	int  ItemNo = 0, i = 0;

	memset(bitmaps, 0, sizeof(bitmaps));
	memset(key, 0, sizeof(key));

	memcpy(sendbuf,buf,33);

	sprintf(key, "BITMAPS %04d", bs->optcode);

	if(GetValueFromEtcFile(etcfile, key, "REQUEST", bitmaps, 512) != ETC_OK )
	{
		bms_trace("GetValueFromEtcFile FOR REQUEST of [%d] failed", bs->optcode);
	  	return FAILURE;
	}

	ItemNo = GetFieldCount(bitmaps, ',');
	if(ItemNo == 0)
	{
		bms_trace("No bitmaps defined in etcfile");
		return FAILURE;
	}

	for(i = 0; i < ItemNo; i++)
	{
		memset(TotalItem, 0, sizeof(TotalItem));
		memset(len_field, 0, sizeof(len_field));
		memset(buffer, 0, sizeof(buffer));
		GetField(bitmaps, ',', TotalItem, i + 1);

		GetField(TotalItem, ':', host_field, 1);
		GetField(TotalItem, ':', bs_field, 2);
		GetField(TotalItem, ':', len_field,3);

		host_field[6] = 0;
		bs_field[3] = 0;
		len_field[2] = 0;

		memset(buffer, 0, sizeof(buffer));
		GetValueFromBigStruct(buffer, bs_field, bs);
		strncat(buffer,"                                                                                                                                                               ",64);
		strncat(sendbuf,buffer,atoi(len_field));
		
	}

	return SUCCESS;
}

int UnPack(BIG_STRC *bs, char *recvbuff)
{
	char ErrorCode[7 + 1], ErrorMsg[128];
	char detail_buf[10240];
	char bitmaps[512], key[128], TotalItem[7 + 1];
	char host_field[3 + 1], bs_field[3 + 1], field[3 + 1],len_field[2 + 1];
	char buffer[128], err_len[4 + 1];
	char orgfile[128];
	FILE *fp;
	int  ItemNo = 0, i = 0, j = 0;
	int index = 0;
	int lines = 0;

	
	memset(ErrorCode, 0, sizeof(ErrorCode));
	memset(ErrorMsg, 0, sizeof(ErrorMsg));

	GetErrorCode(recvbuff, ErrorCode);
	
	index += 11;		//4位交易码＋7位错误返回码
	if( strcmp(ErrorCode, "0000000") != 0 && strcmp(ErrorCode,"       ") != 0 )
	{
		memcpy(err_len, recvbuff + index ,4);
		index += 4 ;		//4位错误信息长度
		memcpy(ErrorMsg, recvbuff + index, atoi(err_len));
		bms_trace("OptCode=[%d] ErrorCode=[%s] ErrorMsg=[%s]\n", bs->optcode,ErrorCode,ErrorMsg);
		Process_Host_Err(ErrorCode,&bs->result);
		//memcpy(bs->notes10,ErrorCode,7);
		//memcpy(bs->notes10+7,ErrorMsg,strlen(ErrorMsg));
		memcpy(bs->errinfo,ErrorMsg,strlen(ErrorMsg));
		return FAILURE;
	}
	if (debug) 
		bms_trace("ErrorCode = [%s] ErrorMsg = [%s]\n", ErrorCode,ErrorMsg);
	
	

	memset(bitmaps, 0, sizeof(bitmaps));
  	memset(key, 0, sizeof(key));

  	sprintf(key, "BITMAPS %04d", bs->optcode);
	if (debug) 
        	bms_trace("%s",key);
	index += 4;			//4位考核网点
	
  	if(GetValueFromEtcFile(etcfile, key, "RESPONSE", bitmaps, 512) != ETC_OK)
  	{
       		bms_trace("GetValueFromEtcFile FOR RESPONSE of [%d] failed", bs->optcode);
          	return FAILURE;
  	}
	if (debug) 
        	bms_trace("GetValueFromEtcFile FOR RESPONSE of [%d] SUCCESS", bs->optcode);

	//ItemNo = GetFieldCount(bitmaps, ',');
	if( strcmp(bitmaps,"") == 0 || strcmp(bitmaps,"NONE") == 0 )
	{
          	bms_trace("No bitmaps defined 0 in etcfile");
          	goto noresponse;
	}
	ItemNo = GetFieldCount(bitmaps, ',');
	
	if (debug) 
        	bms_trace("UnPack ItemNo [%d] ", ItemNo);

	for(i = 0; i < ItemNo; i++)
	{
		memset(TotalItem, 0, sizeof(TotalItem));
		memset(host_field, 0, sizeof(host_field));
		GetField(bitmaps, ',', TotalItem, i + 1);

		GetField(TotalItem, ':', host_field, 1);
		GetField(TotalItem, ':', bs_field, 2);
		GetField(TotalItem, ':', len_field, 3);

		bs_field[3] = 0;
		len_field[2] = 0;

		memset(buffer, 0, sizeof(buffer));
		memcpy(buffer, recvbuff + index , atoi(len_field));
		index += atoi(len_field);	
		pub_trim(buffer);
		SetValueToBigStruct(bs, bs_field, buffer);

	}

noresponse:

	memset(detail_buf, 0, sizeof(detail_buf));
	strcpy(detail_buf, recvbuff + index);

	switch(bs->optcode)
	{
		case 1000:
		case 1001://查余额
		case 1002://查历史明细
		case 1003:
		case 1004:
		case 1100:
		case 1101:
		case 1102:
		case 1103:
		case 1200:
		case 1203:
		case 1204:
		case 1205:
		case 1206:
		case 1208:
		case 1801:
		case 1802:
		case 1803:
		case 1804:
		case 1806:
		case 1808:
			bms_trace("ProduceFile Begin....!");
			if( ProduceFile(detail_buf, bs) == FAILURE)
			{
				bms_trace("ErrorMsg = [%s]\n", ErrorMsg);
				bs->result = PROCUDE_DETAIL_FILE_ERROR;
				return FAILURE;
			}
			bms_trace("ProduceFile end!!!");
			break;
		default:
			break;
	}
	return SUCCESS;
}

int ProduceFile(char *packet, BIG_STRC *bs)
{
	FILE *fax, *ivr;
	char bitmaps[512], key[128], TotalItem[7 + 1];
	char host_field[3 + 1], bs_field[3 + 1], field[3 + 1];
	char buffer[128], orgfile[128];
	FILE *fp;
	int  ItemNo = 0, i = 0, j = 0;
	int  lines = 0;
	int index = 0 ;
	
	memset(bitmaps, 0, sizeof(bitmaps));
	memset(key, 0, sizeof(key));
  	memset(TotalItem, 0, sizeof(TotalItem));
  	memset(buffer, 0, sizeof(buffer));

  	sprintf(key, "BITMAPS %04d", bs->optcode);

	if(GetValueFromEtcFile(etcfile, key, "RSPN_DTL", bitmaps, 512) != ETC_OK)
    	{
		bms_trace("GetValueFromEtcFile FOR RSPN_DTL of [%d] failed", bs->optcode);
		return FAILURE;
    	}

	if( strcmp(bitmaps,"") || strcmp(bitmaps,"NONE") )
	{
		ItemNo = GetFieldCount(bitmaps, ',');
		if(ItemNo == 0)
		{
			bms_trace("No bitmaps defined 0 in etcfile");
			//bs->result = UNPACK_ERROR;
			return FAILURE;
		}
	}

	lines = bs->detail_num ;	//明细项数

	memset(orgfile, 0, sizeof(orgfile));
	sprintf(orgfile, "%s/tmp/%s",  getenv("HOME"), bs->address) ;
	
	if( (fp = fopen(orgfile, "ab+")) == NULL )
	{
		bs->result = FILE_OPEN_ERROR;
		strcpy(bs->notes10, "创建原文件失败");
		return FAILURE;
	}
	for(i = 0; i < lines; i++)
	{
		memset(dp.sb[dp.sn].buf, '\0', sizeof(dp.sb[ dp.sn].buf)) ;

		for(j = 0; j < ItemNo; j++)
		{
			memset(field, 0, sizeof(field));
			GetField(bitmaps, ',', field, j + 1);
			
			memset(buffer, 0, sizeof(buffer));
			memcpy(buffer, packet + index , atoi(field));
			strcat((char *)dp.sb[dp.sn].buf, (char *)alltrim(buffer));
			strcat((char *)dp.sb[dp.sn].buf, "|");
			index += atoi(field);
		}
		fprintf(fp,"%s\n",(char *)dp.sb[dp.sn].buf);
		dp.sn++;
	}
	fflush(fp);
	fclose(fp);
	
	return SUCCESS;
}

/*
 * The followings are local functions.
 */
static void pub_get_yearsecond( char *str)
{
	struct tm *current_time, time_buf ;
	time_t t1 ;

	current_time = &time_buf ;
	time( &t1) ;
	current_time = localtime ( &t1) ;

	current_time -> tm_year = current_time -> tm_year + 1900 ; 
	sprintf( str , "%02d%02d%02d%02d%02d",
		current_time -> tm_mon + 1,
		current_time -> tm_mday,
		current_time -> tm_hour,
		current_time -> tm_min,
		current_time -> tm_sec) ;
	return ;
}

/*
 * function	: GetValueFromBigStruct
 * input	: fieldno, BIG_STRC
 *		: SUCCESS / FAILURE
 */
static int GetValueFromBigStruct(char *value, char *fieldno, BIG_STRC *bs)
{
	char buffer[128];

	memset(buffer, 0, sizeof(buffer));

	switch(atoi(fieldno))
	{
		case 0:
			strcpy(buffer, "");
			break;
		case 1:
			sprintf(buffer, "%s", bs->teller);
			break;
		case 2:
			sprintf(buffer, "%d", bs->trade_serial);
			break;
		case 3:
			sprintf(buffer, "%d", bs->otrade_serial);
			break;
		case 4:
			sprintf(buffer, "%s", bs->flag);
			break;
		case 5:
			sprintf(buffer, "%d", bs->side);
			break;
		case 6:
			sprintf(buffer, "%d", bs->optcode);
			break;
		case 7:
			sprintf(buffer, "%s", bs->serv_type);
			break;
		case 8:
			sprintf(buffer, "%d", bs->busin_type);
			break;
		case 9:
			sprintf(buffer, "%d", bs->trade_type);
			break;
		case 10:
			sprintf(buffer, "%d", bs->result);
			break;
		case 11:
			sprintf(buffer, "%s", bs->serv_date);
			break;
		case 12:
			sprintf(buffer, "%s", bs->serv_time);
			break;
		case 13:
			sprintf(buffer, "%s", bs->auther);
			break;
		case 14:
			sprintf(buffer, "%s", bs->auth_no);
			break;
		case 15:
			sprintf(buffer, "%d", bs->zoneno);
			break;
		case 16:
			sprintf(buffer, "%d", bs->ctype);
			break;
		case 17:
			sprintf(buffer, "%s", bs->cid);
			break;
		case 18:
			sprintf(buffer, "%d", bs->bid);
			break;
		case 19:
			sprintf(buffer, "%s", bs->debi_aid);
			break;
		case 20:
			sprintf(buffer, "%d", bs->debi_acct_type);
			break;
		case 21:
			sprintf(buffer, "%s", bs->debi_bank);
			break;
		case 22:
			sprintf(buffer, "%s", bs->debi_acct);
			break;
		case 23:
			sprintf(buffer, "%d", bs->debi_curr);
			break;
		case 24:
			sprintf(buffer, "%s", bs->cred_aid);
			break;
		case 25:
			sprintf(buffer, "%d", bs->cred_acct_type);
			break;
		case 26:
			sprintf(buffer, "%s", bs->cred_bank);
			break;
		case 27:
			sprintf(buffer, "%s", bs->cred_acct);
			break;
		case 28:
			sprintf(buffer, "%d", bs->cred_curr);
			break;
		case 29:
			sprintf(buffer, "%.2lf", bs->debi_amt);