Exemplo n.º 1
0
void netstackUDPIPProcess(unsigned int len, udpip_hdr* packet)
{
	uint16_t payloadlen = 0;
	uint8_t* payloaddata = 0;
	uint16_t i;

	// get UDP payload length
	payloadlen = htons(packet->udp.udplen);
	payloadlen -= 8; // subtract header
	// get UDP payload data
	payloaddata = &((unsigned char*)packet)[IP_HEADER_LEN+UDP_HEADER_LEN];

	rprintf("UDP packet, len: %d\r\n", len);
	//debugPrintHexTable(len, (unsigned char*)packet);

	if (packet->udp.destport == HTONS(CONTROL_PORT))
	{
		// command packet
		processCommand(payloadlen, payloaddata);
	}
	else if (packet->udp.destport == HTONS(SERIAL_PORT))
	{
		// serial output
		for (i=0; i<payloadlen; i++)
			uartSendByte(payloaddata[i]);
	}
	else if (packet->udp.destport == HTONS(LOOPBACK_PORT))
	{
		// loopback - return packet to sender
		udpSend(htonl(packet->ip.srcipaddr), LOOPBACK_PORT, payloadlen, payloaddata);
	}
}
Exemplo n.º 2
0
void dhcpRequest(void)
{
	struct netDhcpHeader* packet;
	uint32_t val;

	packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];

	// build BOOTP/DHCP header
	packet->bootp.op = BOOTP_OP_BOOTREQUEST;	// request type
	packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
	packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
	packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
	packet->bootp.yiaddr = HTONL(0l);
	packet->bootp.siaddr = HTONL(0l);
	packet->bootp.giaddr = HTONL(0l);
	nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
	packet->bootp.xid = DhcpTransactID;
	packet->bootp.flags = HTONS(1);

	// build DHCP request
	// begin with magic cookie
	packet->cookie = 0x63538263;
	// set operation
	val = DHCP_MSG_DHCPDISCOVER;
	dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);

	#ifdef DHCP_DEBUG
	rprintfProgStrM("DHCP: Sending Query\r\n");
	//dhcpPrintHeader(packet);
	#endif

	// send request
	udpSend(0xFFFFFFFF, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+1, (uint8_t*)packet);
}
Exemplo n.º 3
0
/// a useful function to write a UDP packet prefixed by a timestamp
/// and formatted with printf semantics.
void udpwrite(const char *s,...){
    va_list args;
    va_start(args,s);
    char buf[1024];
    sprintf(buf,"time=%f ",gettime());
    vsnprintf(buf+strlen(buf),1024-strlen(buf),s,args);
    //printf("%s\n",buf);
    udpSend(serverAddr,outport,buf); // SEND TO 
    va_end(args);
}
Exemplo n.º 4
0
void procPerMessage::dnsSend(int protocol_id, Message* msg)
{
    //Add header and send
    dnsHeader *header = new dnsHeader;
    header->hlp = protocol_id;
    header->m_size = msg->msgLen();

    msg->msgAddHdr((char *)header, sizeof(dnsHeader));
    udpSend(DNS_ID, msg);

    delete header;
}
Exemplo n.º 5
0
// Thread function
void* signalerTaskFunction(void *arg)
{
	(void)arg;

	for (;;)
	{
		// Wait for notification from UDP
		sem_wait(&notify_sem);

		udpSend("SIGNAL_ACK");
	}

	return NULL;
}
Exemplo n.º 6
0
void serviceLocal(void)
{
	int c;
	unsigned char buffer[100];

	if ( (c = uartGetByte()) != -1)
	{
		// echo command to terminal
		rprintfChar(c);
		// process command
		switch (c)
		{
		case 'i':
			rprintfProgStrM("\r\nInitializing Ethernet Controller\r\n");
			nicInit();
			break;
		case 'd':
			rprintfProgStrM("\r\nEthernet Controller State\r\n");
			nicRegDump();
			break;
		case 't':
			rprintfProgStrM("\r\nCurrent Uptime: ");
			rprintfNum(10, 9, FALSE, ' ', UptimeMs);
			rprintfProgStrM("ms\r\n");
			break;
		case 'c':
			rprintfProgStrM("\r\nCrashing System....\r\n");
			while(1);
			break;
		case 'u':
			rprintfProgStrM("\r\nSending UDP packet\r\n");
			strcpy((char*)&buffer[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN], "hello");
			udpSend((ipGetConfig()->ip|~ipGetConfig()->netmask), CONTROL_PORT, 6, &buffer[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN]);
			break;
		case '?':
			rprintfProgStrM("\r\nCommands:\r\n");
			rprintfProgStrM("(i) Initialize Ethernet Controller\r\n");
			rprintfProgStrM("(d) Dump Ethernet Controller State\r\n");
			rprintfProgStrM("(u) Send Broadcast UDP frame\r\n");
			rprintfProgStrM("(t) Print current uptime\r\n");
			rprintfProgStrM("(?) Help\r\n");
			break;
		case '\n':
		default:
			break;
		}
		// print new prompt
		rprintfProgStrM("\r\ncmd>");
	}
}
Exemplo n.º 7
0
void dhcpRelease(void)
{
	struct netDhcpHeader* packet;
	uint32_t val;
	uint8_t* optptr;

	packet = (struct netDhcpHeader*)&netstackGetBuffer()[ETH_HEADER_LEN+IP_HEADER_LEN+UDP_HEADER_LEN];

	// build BOOTP/DHCP header
	packet->bootp.op = BOOTP_OP_BOOTREQUEST;	// request type
	packet->bootp.htype = BOOTP_HTYPE_ETHERNET;
	packet->bootp.hlen = BOOTP_HLEN_ETHERNET;
	packet->bootp.ciaddr = htonl(ipGetConfig()->ip);
	packet->bootp.yiaddr = HTONL(0l);
	packet->bootp.siaddr = HTONL(0l);
	packet->bootp.giaddr = HTONL(0l);
	nicGetMacAddress(&packet->bootp.chaddr[0]); // fill client hardware address
	packet->bootp.xid = DhcpTransactID;			// set trans ID (use part of MAC address)
	packet->bootp.flags = HTONS(1);

	// build DHCP request
	// begin with magic cookie
	packet->cookie = 0x63538263;
	// set operation
	val = DHCP_MSG_DHCPRELEASE;
	optptr = dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
	// set the server ID
	val = htonl(DhcpServerIP);
	optptr = dhcpSetOption(optptr, DHCP_OPT_SERVERID, 4, &val);
	// request the IP previously offered
	optptr = dhcpSetOption(optptr, DHCP_OPT_REQUESTEDIP, 4, &packet->bootp.ciaddr);

	#ifdef DHCP_DEBUG
	rprintfProgStrM("DHCP: Sending Release to "); netPrintIPAddr(DhcpServerIP); rprintfCRLF();
	//dhcpPrintHeader(packet);
	#endif

	// send release
	udpSend(DhcpServerIP, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+6+6+1, (uint8_t*)packet);

	// deconfigure ip addressing
	ipSetConfig(0,0,0);
	DhcpLeaseTime = 0;
}
Exemplo n.º 8
0
void pwmCompleteMotorUpdate(uint8_t motorCount) {
    UNUSED(motorCount);
    // send to simulator
    // for gazebo8 ArduCopterPlugin remap, normal range = [0.0, 1.0], 3D rang = [-1.0, 1.0]

    double outScale = 1000.0;
    if (feature(FEATURE_3D)) {
        outScale = 500.0;
    }

    pwmPkt.motor_speed[3] = motorsPwm[0] / outScale;
    pwmPkt.motor_speed[0] = motorsPwm[1] / outScale;
    pwmPkt.motor_speed[1] = motorsPwm[2] / outScale;
    pwmPkt.motor_speed[2] = motorsPwm[3] / outScale;

    // get one "fdm_packet" can only send one "servo_packet"!!
    if (pthread_mutex_trylock(&updateLock) != 0) return;
    udpSend(&pwmLink, &pwmPkt, sizeof(servo_packet));
//    printf("[pwm]%u:%u,%u,%u,%u\n", idlePulse, motorsPwm[0], motorsPwm[1], motorsPwm[2], motorsPwm[3]);
}
Exemplo n.º 9
0
int  sendBuf( rbudpSender_t *rbudpSender, void * buffer, int bufSize,
              int sendRate, int packetSize ) {
    int done = 0;
    int status = 0;
    struct timeval curTime, startTime;
    double srate;
    gettimeofday( &curTime, NULL );
    startTime = curTime;
    int lastRemainNumberOfPackets = 0;
    int noProgressCnt = 0;
    initSendRudp( rbudpSender, buffer, bufSize, sendRate, packetSize );
    while ( !done ) {
        // blast UDP packets
        if ( rbudpSender->rbudpBase.verbose > 1 ) {
            TRACE_DEBUG( "sending UDP packets" );
        }
        reportTime( &curTime );
        status = udpSend( rbudpSender );
        if ( status < 0 ) {
            return status;
        }

        srate = ( double ) rbudpSender->rbudpBase.remainNumberOfPackets *
                rbudpSender->rbudpBase.payloadSize * 8 /
                ( double ) reportTime( &curTime );
        if ( rbudpSender->rbudpBase.verbose > 1 ) {
            TRACE_DEBUG( "real sending rate in this send is %f", srate );
        }

        if ( lastRemainNumberOfPackets == 0 ) {
            lastRemainNumberOfPackets =
                rbudpSender->rbudpBase.remainNumberOfPackets;
        }
        // send end of UDP signal
        if ( rbudpSender->rbudpBase.verbose > 1 )
            TRACE_DEBUG( "send to socket %d an end signal.",
                         rbudpSender->rbudpBase.tcpSockfd );
        if ( rbudpSender->rbudpBase.verbose > 1 ) {
            fprintf( stderr, "write %d bytes.\n", ( int ) sizeof( rbudpSender->rbudpBase.endOfUdp ) );
        }
        int error_code = writen( rbudpSender->rbudpBase.tcpSockfd, ( char * )&rbudpSender->rbudpBase.endOfUdp,
                                 sizeof( rbudpSender->rbudpBase.endOfUdp ) );
        if ( error_code < 0 ) {
            rodsLog( LOG_ERROR, "writen failed in sendBuf with error code %d", error_code );
        }
        rbudpSender->rbudpBase.endOfUdp.round ++;

        reportTime( &curTime );
        gettimeofday( &curTime, NULL );
        if ( rbudpSender->rbudpBase.verbose > 1 ) {
            TRACE_DEBUG( "Current time: %d %ld", curTime.tv_sec, curTime.tv_usec );
        }

        // receive error list
        if ( rbudpSender->rbudpBase.verbose > 1 ) {
            TRACE_DEBUG( "waiting for error bitmap" );
        }

        int n = readn( rbudpSender->rbudpBase.tcpSockfd,
                       rbudpSender->rbudpBase.errorBitmap,
                       rbudpSender->rbudpBase.sizeofErrorBitmap );
        if ( n < 0 ) {
            perror( "read" );
            return errno ? ( -1 * errno ) : -1;
        }

        if ( ( unsigned char )rbudpSender->rbudpBase.errorBitmap[0] == 1 ) {
            done = 1;
            rbudpSender->rbudpBase.remainNumberOfPackets = 0;
            if ( rbudpSender->rbudpBase.verbose > 1 ) {
                TRACE_DEBUG( "done." );
            }
        }
        else {
            rbudpSender->rbudpBase.remainNumberOfPackets =
                updateHashTable( &rbudpSender->rbudpBase );
            if ( rbudpSender->rbudpBase.remainNumberOfPackets >=
                    lastRemainNumberOfPackets ) {
                noProgressCnt++;
                if ( noProgressCnt >= MAX_NO_PROGRESS_CNT ) {
                    return SYS_UDP_TRANSFER_ERR - errno;
                }
            }
            else {
                lastRemainNumberOfPackets =
                    rbudpSender->rbudpBase.remainNumberOfPackets;
                noProgressCnt = 0;
            }
        }

        if ( rbudpSender->rbudpBase.isFirstBlast ) {
            rbudpSender->rbudpBase.isFirstBlast = 0;
            double lossRate =
                ( double )rbudpSender->rbudpBase.remainNumberOfPackets /
                ( double )rbudpSender->rbudpBase.totalNumberOfPackets;
            //	if (rbudpSender->rbudpBase.remainNumberOfPackets > 0)
            //	    usecsPerPacket = (int) ((double)usecsPerPacket / (1.0 - lossRate - 0.05));
            if ( rbudpSender->rbudpBase.verbose > 0 ) {
                float dt = ( curTime.tv_sec - startTime.tv_sec )
                           + 1e-6 * ( curTime.tv_usec - startTime.tv_usec );
                float mbps = 1e-6 * 8 * bufSize / ( dt == 0 ? .01 : dt );
                TRACE_DEBUG( "loss rate: %f  on %dK in %.3f seconds (%.2f Mbits/s)",
                             lossRate, ( int )bufSize >> 10, dt, mbps );
                if ( rbudpSender->rbudpBase.verbose > 1 )
                    TRACE_DEBUG( "usecsPerPacket updated to %d",
                                 rbudpSender->rbudpBase.usecsPerPacket );
            }
        }
Exemplo n.º 10
0
void dhcpIn(unsigned int len, struct netDhcpHeader* packet)
{
	uint8_t msgtype;
	uint32_t sid;
	uint8_t* optptr;
	uint32_t val;
	uint32_t netmask;
	uint32_t gateway;

	#if NET_DEBUG >= 3
	dhcpPrintHeader(packet);
	#endif

	// check that this is a reply, and for me
	if ((packet->bootp.op != BOOTP_OP_BOOTREPLY) || (packet->bootp.xid != DhcpTransactID))
		return;
	
	// process incoming packet
	// check reply type
	dhcpGetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &msgtype);
	#if NET_DEBUG >= 2
	rprintf("DHCP: Received msgtype = %d\r\n", msgtype);
	#endif

	if (msgtype == DHCP_MSG_DHCPOFFER)
	{
		// get DHCP server ID
		dhcpGetOption(packet->options, DHCP_OPT_SERVERID, 4, &sid);
		#ifdef DHCP_DEBUG
		rprintfProgStrM("DHCP: Got offer from server "); netPrintIPAddr(htonl(sid)); rprintfCRLF();
		#endif

		// build DHCP request (on top of this reply)
		packet->bootp.op = BOOTP_OP_BOOTREQUEST;	// request type
		// set operation
		val = DHCP_MSG_DHCPREQUEST;
		optptr = dhcpSetOption(packet->options, DHCP_OPT_DHCPMSGTYPE, 1, &val);
		// set the server ID
		optptr = dhcpSetOption(optptr, DHCP_OPT_SERVERID, 4, &sid);
		// request the IP previously offered
		optptr = dhcpSetOption(optptr, DHCP_OPT_REQUESTEDIP, 4, &packet->bootp.yiaddr);
		// request additional information
		((uint8_t*)&val)[0] = DHCP_OPT_NETMASK;
		((uint8_t*)&val)[1] = DHCP_OPT_ROUTERS;
		((uint8_t*)&val)[2] = DHCP_OPT_DNSSERVERS;
		((uint8_t*)&val)[3] = DHCP_OPT_DOMAINNAME;
		optptr = dhcpSetOption(optptr, DHCP_OPT_PARAMREQLIST, 4, &val);

		#ifdef DHCP_DEBUG
		rprintfProgStrM("DHCP: Sending request in response to offer\r\n");
		#endif
		// send DHCP request
		DhcpServerIP = htonl(sid);
		udpSend(DhcpServerIP, DHCP_UDP_SERVER_PORT, DHCP_HEADER_LEN+3+6+6+6+1, (uint8_t*)packet);
	}
	else if (msgtype == DHCP_MSG_DHCPACK)
	{
		// get netmask
		dhcpGetOption(packet->options, DHCP_OPT_NETMASK, 4, &val);
		netmask = htonl(val);
		// get gateway
		dhcpGetOption(packet->options, DHCP_OPT_ROUTERS, 4, &val);
		gateway = htonl(val);
		// get lease time
		dhcpGetOption(packet->options, DHCP_OPT_LEASETIME, 4, &val);
		DhcpLeaseTime = htonl(val);

		// assign new network info
		ipSetConfig(htonl(packet->bootp.yiaddr), netmask, gateway);

		#ifdef DHCP_DBUG
		rprintf("DHCP: Got request ACK, bind complete\r\n");
		//debugPrintHexTable(len-DHCP_HEADER_LEN, (packet->options));
		// print info
		ipPrintConfig(ipGetConfig())
		rprintfProgStrM("LeaseTm : "); rprintfNum(10, 8, FALSE, ' ', DhcpLeaseTime); rprintfCRLF();
		#endif
	}

}
Exemplo n.º 11
0
void wmpImage(int *state)
{
	int rc = 0;
	char *addr = (char *)wtpinfoGetACIPStr();
	char *dir = (char *)wtpInfoGetBoardName();
	char *file = S_img.name;
	char *imgdwn = "/sbin/imgdwn.sh %s %s %s";
	char *imgwr = "/sbin/imgwr.sh %s";
	char cmd[1024] = { 0 };
	WMMSG msg;
	BUFF attr;
	uint16_t seqnum = 0;
	uint8_t *apid = NULL;

	if (snprintf(cmd, sizeof(cmd), imgdwn, addr, dir, file) < 1) {
		logError("snprintf : %s", strerror(errno));
		rc = -1;
		goto out;
	}
	//  下载固件
	if (utilDoCMD(cmd)) {
		logError("Down firmware error");
		rc = -1;
		goto out;
	}
	//  对比固件MD5
	if (imageFileMD5Chk(file, S_img.filehash)) {
		logError("Image file \"%s\" MD5 hash is error");
		rc = -1;
		goto out;
	}
	//  写固件
	memset(cmd, 0, sizeof(cmd));
	if (snprintf(cmd, sizeof(cmd), imgwr, file) < 1) {
		logError("snprintf : %s", strerror(errno));
		rc = -1;
		goto out;
	}
	if (utilDoCMD(cmd)) {
		logError("Write firmware error");
		rc = -1;
	}
out :
	apid = (uint8_t *)wtpidGetBytes();
	seqnum = wtpInfoGetSEQNUM();
	wmmClearInit(&msg, apid, seqnum, WMM_CODE_IMGUP_REP);
	if (0 == rc) {
		//  报告AC固件处理完毕,准备重启
		wmmPackResCode(&attr, WMM_RESULT_CODE_OK);
	} else {
		//  报告AC固件处理出现错误,准备重启
		wmmPackResCode(&attr, WMM_RESULT_CODE_FAILED);
	}
	wmmPutAttrBuff(&msg, &attr);
	if (udpSend(G_wmpsock, msg.buff, msg.offset, &G_wmpaddr) < 1) {
		logError("sendto : %s", strerror(errno));
	}

	sleep(10);
	logError("Now Reboot!!!");
	utilDoCMD("reboot");
}
Exemplo n.º 12
0
void sendMotorUpdate() {
    udpSend(&pwmLink, &pwmPkt, sizeof(servo_packet));
}
Exemplo n.º 13
0
/* Process a specific test case. File name is provided.
 * Needs to return 0 if all is OK, something else otherwise.
 */
int
processTestFile(int fd, char *pszFileName)
{
	FILE *fp;
	char *testdata = NULL;
	char *expected = NULL;
	int ret = 0;
	size_t lenLn;
	char buf[4096];

	if((fp = fopen((char*)pszFileName, "r")) == NULL) {
		perror((char*)pszFileName);
		return(2);
	}

	/* skip comments at start of file */

	while(!feof(fp)) {
		getline(&testdata, &lenLn, fp);
		while(!feof(fp)) {
			if(*testdata == '#')
				getline(&testdata, &lenLn, fp);
			else
				break; /* first non-comment */
		}

		/* this is not perfect, but works ;) */
		if(feof(fp))
			break;

		++iTests; /* increment test count, we now do one! */

		testdata[strlen(testdata)-1] = '\0'; /* remove \n */
		/* now we have the test data to send (we could use function pointers here...) */
		unescapeTestdata(testdata);
		if(inputMode == inputUDP) {
			if(udpSend(testdata, strlen(testdata)) != 0)
				return(2);
		} else {
			if(tcpSend(testdata, strlen(testdata)) != 0)
				return(2);
		}

		/* next line is expected output 
		 * we do not care about EOF here, this will lead to a failure and thus
		 * draw enough attention. -- rgerhards, 2009-03-31
		 */
		getline(&expected, &lenLn, fp);
		expected[strlen(expected)-1] = '\0'; /* remove \n */

		/* pull response from server and then check if it meets our expectation */
		readLine(fd, buf);
		if(strcmp(expected, buf)) {
			++iFailed;
			printf("\nExpected Response:\n'%s'\nActual Response:\n'%s'\n",
				expected, buf);
				ret = 1;
		}
		/* we need to free buffers, as we have potentially modified them! */
		free(testdata);
		testdata = NULL;
		free(expected);
		expected = NULL;
	}

	free(expected);
	fclose(fp);
	return(ret);
}
Exemplo n.º 14
0
/*
	Main
*/
int main(int argc, char ** argv)
{
	struct sockaddr_in	inaddr;
	socklen_t		inaddrlen;
	struct timeval	timeout;
	ssl_t			*ssl;
	serverDtls_t	*dtlsCtx;
	SOCKET			sock;
	fd_set			readfd;
	unsigned char	*sslBuf, *recvfromBuf, *CAstream;
#ifdef USE_DTLS_DEBUG_TRACE	
	unsigned char   *addrstr;
#endif
#if !defined(ID_PSK) && !defined(ID_DHE_PSK)
	unsigned char   *keyValue, *certValue;
	int32           keyLen, certLen;
#endif	
	sslKeys_t		*keys;
	int32			freeBufLen, rc, val, recvLen, err, CAstreamLen;
	int32			sslBufLen, rcr, rcs, sendLen, recvfromBufLen;
	sslSessOpts_t	options;

#ifdef WIN32
	WSADATA         wsaData;
	WSAStartup(MAKEWORD(1, 1), &wsaData);
#endif

	rc = 0;
	ssl = NULL;
	dtlsCtx = NULL;
	sock = INVALID_SOCKET;

	/* parse input arguments */
	if (0 != process_cmd_options(argc, argv)) {
		usage();
		return 0;
	}

	if (sigsetup() < 0) {
		_psTrace("Init error creating signal handlers\n");
		return DTLS_FATAL;
	}

	if (matrixSslOpen() < 0) {
		_psTrace("Init error opening MatrixDTLS library\n");
		return DTLS_FATAL;
	}
	if (matrixSslNewKeys(&keys, NULL) < 0) {
		_psTrace("Init error allocating key structure\n");
		matrixSslClose();
		return DTLS_FATAL;
	}

	if ((rc = initClientList(MAX_CLIENTS)) < 0) {
		_psTrace("Init error opening client list\n");
		goto MATRIX_EXIT;
	}

	recvfromBufLen = matrixDtlsGetPmtu();
	if ((recvfromBuf = psMalloc(MATRIX_NO_POOL, recvfromBufLen)) == NULL) {
		rc = PS_MEM_FAIL;
		_psTrace("Init error allocating receive buffer\n");
		goto CLIENT_EXIT;
	}

#ifdef USE_HEADER_KEYS
/*
	In-memory based keys
	Build the CA list first for potential client auth usage
*/
	CAstreamLen = 0;
#ifdef USE_RSA
	CAstreamLen += sizeof(RSACAS);
#ifdef USE_ECC
	CAstreamLen += sizeof(ECDHRSACAS);
#endif
#endif
#ifdef USE_ECC
	CAstreamLen += sizeof(ECCAS);
#endif
	CAstream = psMalloc(NULL, CAstreamLen);

	CAstreamLen = 0;
#ifdef USE_RSA
	memcpy(CAstream, RSACAS, sizeof(RSACAS));
	CAstreamLen += sizeof(RSACAS);
#ifdef USE_ECC
	memcpy(CAstream + CAstreamLen, ECDHRSACAS, sizeof(ECDHRSACAS));
	CAstreamLen += sizeof(ECDHRSACAS);
#endif
#endif
#ifdef USE_ECC
	memcpy(CAstream + CAstreamLen, ECCAS, sizeof(ECCAS));
	CAstreamLen += sizeof(ECCAS);
#endif

#ifdef EXAMPLE_RSA_KEYS
	switch (g_rsaKeySize) {
		case 1024:
			certValue = (unsigned char *)RSA1024;
			certLen = sizeof(RSA1024);
			keyValue = (unsigned char *)RSA1024KEY;
			keyLen = sizeof(RSA1024KEY);
			break;
		case 2048:
			certValue = (unsigned char *)RSA2048;
			certLen = sizeof(RSA2048);
			keyValue = (unsigned char *)RSA2048KEY;
			keyLen = sizeof(RSA2048KEY);
			break;
		case 3072:
			certValue = (unsigned char *)RSA3072;
			certLen = sizeof(RSA3072);
			keyValue = (unsigned char *)RSA3072KEY;
			keyLen = sizeof(RSA3072KEY);
			break;
		case 4096:
			certValue = (unsigned char *)RSA4096;
			certLen = sizeof(RSA4096);
			keyValue = (unsigned char *)RSA4096KEY;
			keyLen = sizeof(RSA4096KEY);
			break;
		default:
			_psTraceInt("Invalid RSA key length (%d)\n", g_rsaKeySize);
			return -1;
	}

	if ((rc = matrixSslLoadRsaKeysMem(keys, (const unsigned char *)certValue,
			certLen, (const unsigned char *)keyValue, keyLen, CAstream,
			CAstreamLen)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream, NULL);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif


#ifdef EXAMPLE_ECDH_RSA_KEYS
	switch (g_ecdhKeySize) {
		case 256:
			certValue = (unsigned char *)ECDHRSA256;
			certLen = sizeof(ECDHRSA256);
			keyValue = (unsigned char *)ECDHRSA256KEY;
			keyLen = sizeof(ECDHRSA256KEY);
			break;
		case 521:
			certValue = (unsigned char *)ECDHRSA521;
			certLen = sizeof(ECDHRSA521);
			keyValue = (unsigned char *)ECDHRSA521KEY;
			keyLen = sizeof(ECDHRSA521KEY);
			break;
		default:
			_psTraceInt("Invalid ECDH_RSA key length (%d)\n", g_ecdhKeySize);
			return -1;
	}

	if ((rc = matrixSslLoadEcKeysMem(keys, (const unsigned char *)certValue,
				certLen, (const unsigned char *)keyValue, keyLen, CAstream,
				CAstreamLen)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream, NULL);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif

#ifdef EXAMPLE_EC_KEYS
	switch (g_eccKeySize) {
		case 192:
			certValue = (unsigned char *)EC192;
			certLen = sizeof(EC192);
			keyValue = (unsigned char *)EC192KEY;
			keyLen = sizeof(EC192KEY);
			break;
		case 224:
			certValue = (unsigned char *)EC224;
			certLen = sizeof(EC224);
			keyValue = (unsigned char *)EC224KEY;
			keyLen = sizeof(EC224KEY);
			break;
		case 256:
			certValue = (unsigned char *)EC256;
			certLen = sizeof(EC256);
			keyValue = (unsigned char *)EC256KEY;
			keyLen = sizeof(EC256KEY);
			break;
		case 384:
			certValue = (unsigned char *)EC384;
			certLen = sizeof(EC384);
			keyValue = (unsigned char *)EC384KEY;
			keyLen = sizeof(EC384KEY);
			break;
		case 521:
			certValue = (unsigned char *)EC521;
			certLen = sizeof(EC521);
			keyValue = (unsigned char *)EC521KEY;
			keyLen = sizeof(EC521KEY);
			break;
		default:
			_psTraceInt("Invalid ECC key length (%d)\n", g_eccKeySize);
			return -1;
	}

	if ((rc = matrixSslLoadEcKeysMem(keys, certValue, certLen,
			keyValue, keyLen, CAstream, CAstreamLen)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream, NULL);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif

#ifdef REQUIRE_DH_PARAMS
	if (matrixSslLoadDhParamsMem(keys, DHPARAM2048, DHPARAM2048_SIZE)
			< 0) {
		_psTrace("Unable to load DH parameters\n");
	}
#endif /* DH_PARAMS */


	psFree(CAstream, NULL);
#else /* USE_HEADER_KEYS */
/*
	File based keys
	Build the CA list first for potential client auth usage
*/
	CAstreamLen = 0;
#ifdef USE_RSA
	if (g_rsaKeySize == 3072)
		CAstreamLen += (int32)strlen(rsaCA3072File) + 1;
	else
		CAstreamLen += (int32)strlen(rsaCAFile) + 1;
#ifdef USE_ECC
	CAstreamLen += (int32)strlen(ecdhRsaCAFile) + 1;
#endif
#endif
#ifdef USE_ECC
	CAstreamLen += (int32)strlen(ecCAFile) + 1;
#endif
	CAstream = psMalloc(NULL, CAstreamLen);
	memset(CAstream, 0x0, CAstreamLen);

	CAstreamLen = 0;
#ifdef USE_RSA
	if (g_rsaKeySize == 3072) {
		memcpy(CAstream, rsaCA3072File,	strlen(rsaCA3072File));
		CAstreamLen += strlen(rsaCA3072File);
	}
	else {
		memcpy(CAstream, rsaCAFile,	strlen(rsaCAFile));
		CAstreamLen += strlen(rsaCAFile);
	}
#ifdef USE_ECC
	memcpy(CAstream + CAstreamLen, ";", 1); CAstreamLen++;
	memcpy(CAstream + CAstreamLen, ecdhRsaCAFile,  strlen(ecdhRsaCAFile));
	CAstreamLen += strlen(ecdhRsaCAFile);
#endif
#endif
#ifdef USE_ECC
	if (CAstreamLen > 0) {
		memcpy(CAstream + CAstreamLen, ";", 1); CAstreamLen++;
	}
	memcpy(CAstream + CAstreamLen, ecCAFile,  strlen(ecCAFile));
#endif

/* Load Identiy */
#ifdef EXAMPLE_RSA_KEYS
	if ((rc = matrixSslLoadRsaKeys(keys, rsaCertFile, rsaPrivkeyFile, NULL,
			(char*)CAstream)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif


#ifdef EXAMPLE_ECDH_RSA_KEYS
	if ((rc = matrixSslLoadEcKeys(keys, ecdhRsaCertFile, ecdhRsaPrivkeyFile,
			NULL, (char*)CAstream)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif

#ifdef EXAMPLE_EC_KEYS
	if ((rc = matrixSslLoadEcKeys(keys, ecCertFile, ecPrivkeyFile, NULL,
			(char*)CAstream)) < 0) {
		_psTrace("No certificate material loaded.  Exiting\n");
		psFree(CAstream);
		matrixSslDeleteKeys(keys);
		matrixSslClose();
		return rc;
	}
#endif

#ifdef REQUIRE_DH_PARAMS
	if (matrixSslLoadDhParams(keys, dhParamFile) < 0) {
		_psTrace("Unable to load DH parameters\n");
	}
#endif


	psFree(CAstream);
#endif /* USE_HEADER_KEYS */


#ifdef USE_PSK_CIPHER_SUITE
	/* The first ID is considered as null-terminiated string for
	   compatibility with OpenSSL's s_client default client identity
	   "Client_identity" */

 	matrixSslLoadPsk(keys,
            	PSK_HEADER_TABLE[0].key,
            	sizeof(PSK_HEADER_TABLE[0].key),
            	PSK_HEADER_TABLE[0].id,
            	strlen((const char *)PSK_HEADER_TABLE[0].id));

	for (rc = 1; rc < PSK_HEADER_TABLE_COUNT; rc++) {
        matrixSslLoadPsk(keys,
            	PSK_HEADER_TABLE[rc].key,
            	sizeof(PSK_HEADER_TABLE[rc].key),
            	PSK_HEADER_TABLE[rc].id,
            	sizeof(PSK_HEADER_TABLE[rc].id));
    }
#endif /* PSK */


	if ((sock = newUdpSocket(NULL, DTLS_PORT, &err)) == INVALID_SOCKET) {
		_psTrace("Error creating UDP socket\n");
		goto DTLS_EXIT;
	}
	_psTraceInt("DTLS server running on port %d\n", DTLS_PORT);

/*
	Server loop
*/
	for (exitFlag = 0; exitFlag == 0;) {
		timeout.tv_sec = 1;
		timeout.tv_usec = 0;
		FD_ZERO(&readfd);
		FD_SET(sock, &readfd);
/*
		Always just wait a second for any incoming data.  The primary loop
		mechanism reads data from one source and replies with handshake data
		if needed (that reply may be a resend if reading a repeat message).
		Individual client timeouts are then handled
*/
		val = select(sock+1, &readfd, NULL, NULL, &timeout);

		if (val > 0 && FD_ISSET(sock, &readfd)) {
			psTraceIntDtls("Select woke %d\n", val);
			/* recvfrom data must always go into generic buffer becuase we
			don't yet know who it is from */
			inaddrlen = sizeof(struct sockaddr_in);
			if ((recvLen = (int32)recvfrom(sock, recvfromBuf, recvfromBufLen, 0,
										   (struct sockaddr *)&inaddr, &inaddrlen)) < 0) {
#ifdef WIN32
				if (SOCKET_ERRNO != EWOULDBLOCK &&
						SOCKET_ERRNO != WSAECONNRESET) {
#else
				if (SOCKET_ERRNO != EWOULDBLOCK) {
#endif
					_psTraceInt("recvfrom error %d.  Exiting\n", SOCKET_ERRNO);
					goto DTLS_EXIT;
				}
				continue;
				}
#ifdef USE_DTLS_DEBUG_TRACE
			/* nice for debugging */
			{
				const char *addrstr;
				addrstr = getaddrstring((struct sockaddr *)&inaddr, 1);
				psTraceIntDtls("Read %d bytes ", recvLen);
				psTraceStrDtls("from %s\n", (char*)addrstr);
				psFree(addrstr, NULL);
			}
#endif

			/* Locate the SSL context of this receive and create a new session
			if not found */
			if ((dtlsCtx = findClient(inaddr)) == NULL) {
				memset(&options, 0x0, sizeof(sslSessOpts_t));
				options.versionFlag = SSL_FLAGS_DTLS;
				options.truncHmac = -1;

				if (matrixSslNewServerSession(&ssl, keys,
						certValidator, &options) < 0) {
					rc = DTLS_FATAL; goto DTLS_EXIT;
				}
				if ((dtlsCtx = registerClient(inaddr, sock, ssl)) == NULL) {
					/* Client list is full.  Just have to ignore */
					matrixSslDeleteSession(ssl);
					continue;
				}
			}

			ssl = dtlsCtx->ssl;
			/*  Move socket data into internal buffer */
			freeBufLen = matrixSslGetReadbuf(ssl, &sslBuf);
			psAssert(freeBufLen >= recvLen);
			psAssert(freeBufLen == matrixDtlsGetPmtu());
			memcpy(sslBuf, recvfromBuf, recvLen);

			/*	Notify SSL state machine that we've received more data into the
			ssl buffer retreived with matrixSslGetReadbuf. */
			if ((rcr = matrixSslReceivedData(ssl, recvLen, &sslBuf,
					(uint32*)&freeBufLen)) < 0) {
				clearClient(dtlsCtx);
				continue;	/* Next connection */
			}
			/* Update last activity time and reset timeout*/
			psGetTime(&dtlsCtx->lastRecvTime, NULL);
			dtlsCtx->timeout = MIN_WAIT_SECS;

PROCESS_MORE_FROM_BUFFER:
			/* Process any incoming plaintext application data */
			switch (rcr) {
				case MATRIXSSL_HANDSHAKE_COMPLETE:
					/* This is a resumed handshake case which means we are
					the last to receive handshake flights and we know the
					handshake is complete.  However, the internal workings
					will not flag us officially complete until we receive
					application data from the peer so we need a local flag
					to handle this case so we are not resending our final
					flight */
					dtlsCtx->connStatus = RESUMED_HANDSHAKE_COMPLETE;
					psTraceDtls("Got HANDSHAKE_COMPLETE out of ReceivedData\n");
					break;
				case MATRIXSSL_APP_DATA:
					/* Now safe to clear the connStatus flag that was keeping
					track of the state between receiving the final flight of
					a resumed handshake and receiving application data.  The
					reciept of app data has now internally disabled flight
					resends */
					dtlsCtx->connStatus = 0;
					_psTrace("Client connected.  Received...\n");
					_psTraceStr("%s\n", (char*)sslBuf);
					break;
				case MATRIXSSL_REQUEST_SEND:
					/* Still handshaking with this particular client */
					while ((sslBufLen = matrixDtlsGetOutdata(ssl,
							&sslBuf)) > 0) {
						if ((sendLen = udpSend(dtlsCtx->fd, sslBuf, sslBufLen,
											   (struct sockaddr*)&inaddr,
											   sizeof(struct sockaddr_in),
											   dtlsCtx->timeout,
											   packet_loss_prob,
											   NULL)) < 0) {
							psTraceDtls("udpSend error.  Ignoring\n");
						}
						/* Always indicate the entire datagram was sent as
						there is no way for DTLS to handle partial records.
						Resends and timeouts will handle any problems */
						rcs = matrixDtlsSentData(ssl, sslBufLen);

						if (rcs == MATRIXSSL_REQUEST_CLOSE) {
							psTraceDtls("Got REQUEST_CLOSE out of SentData\n");
							clearClient(dtlsCtx);
							break;
						}
						if (rcs == MATRIXSSL_HANDSHAKE_COMPLETE) {
							/* This is the standard handshake case */
							_psTrace("Got HANDSHAKE_COMPLETE from SentData\n");
							break;
						}
						/* SSL_REQUEST_SEND is handled by loop logic */
					}
					break;
				case MATRIXSSL_REQUEST_RECV:
					psTraceDtls("Got REQUEST_RECV from ReceivedData\n");
					break;
				case MATRIXSSL_RECEIVED_ALERT:
					/* The first byte of the buffer is the level */
					/* The second byte is the description */
					if (*sslBuf == SSL_ALERT_LEVEL_FATAL) {
						psTraceIntDtls("Fatal alert: %d, closing connection.\n",
									*(sslBuf + 1));
						clearClient(dtlsCtx);
						continue; /* Next connection */
					}
					/* Closure alert is normal (and best) way to close */
					if (*(sslBuf + 1) == SSL_ALERT_CLOSE_NOTIFY) {
						clearClient(dtlsCtx);
						continue; /* Next connection */
					}
					psTraceIntDtls("Warning alert: %d\n", *(sslBuf + 1));
					if ((rcr = matrixSslProcessedData(ssl, &sslBuf,
							(uint32*)&freeBufLen)) == 0) {
						continue;
					}
					goto PROCESS_MORE_FROM_BUFFER;

				default:
					continue; /* Next connection */
			}
		} else if (val < 0) {
			if (SOCKET_ERRNO != EINTR) {
				psTraceIntDtls("unhandled error %d from select", SOCKET_ERRNO);
			}
		}
/*
		Have either timed out waiting for a read or have processed a single
		recv.  Now check to see if any timeout resends are required
*/
		rc = handleResends(sock);
	}	/* Main Select Loop */


DTLS_EXIT:
	psFree(recvfromBuf, NULL);
CLIENT_EXIT:
	closeClientList();
MATRIX_EXIT:
	matrixSslDeleteKeys(keys);
	matrixSslClose();
	if (sock != INVALID_SOCKET) close(sock);
	return rc;
}

/******************************************************************************/
/*
	Work through client list and resend handshake flight if haven't heard
	from them in a while
*/
static int32 handleResends(SOCKET sock)
{
	serverDtls_t	*dtlsCtx;
	ssl_t			*ssl;
	psTime_t		now;
	unsigned char	*sslBuf;
	int16			i;
	int32			sendLen, rc;
	uint32			timeout, sslBufLen, clientCount;

	clientCount = 0; /* return code is number of active clients or < 0 on error */
	psGetTime(&now, NULL);
	for (i = 0; i < tableSize; i++) {
		dtlsCtx = &clientTable[i];
		if (dtlsCtx->ssl != NULL) {
			clientCount++;
			timeout = psDiffMsecs(dtlsCtx->lastRecvTime, now, NULL) / 1000;
			/* Haven't heard from this client in a while.  Might need resend */
			if (timeout > dtlsCtx->timeout) {
				/* if timeout is too great. clear conn */
				if (dtlsCtx->timeout >= MAX_WAIT_SECS) {
					clearClient(dtlsCtx);
					clientCount--;
					break;
				}
				/* Increase the timeout for next pass */
				dtlsCtx->timeout *= 2;

				/* If we are in a RESUMED_HANDSHAKE_COMPLETE state that means
				we are positive the handshake is complete so we don't want to
				resend no matter what.  This is an interim state before the
				internal mechaism sees an application data record and flags
				us as complete officially */
				if (dtlsCtx->connStatus == RESUMED_HANDSHAKE_COMPLETE) {
					psTraceDtls("Connected but awaiting data\n");
					continue;
				}
				ssl = dtlsCtx->ssl;
				while ((sslBufLen = matrixDtlsGetOutdata(ssl,
						&sslBuf)) > 0) {
					if ((sendLen = udpSend(dtlsCtx->fd, sslBuf, sslBufLen,
										   (struct sockaddr*)&dtlsCtx->addr,
										   sizeof(struct sockaddr_in),
										   dtlsCtx->timeout / 2,
										   packet_loss_prob,
										   NULL)) < 0) {
						psTraceDtls("udpSend error.  Ignoring\n");
					}
					/* Always indicate the entire datagram was sent as
					there is no way for DTLS to handle partial records.
					Resends and timeouts will handle any problems */
					if ((rc = matrixDtlsSentData(ssl, sslBufLen)) < 0) {
						psTraceDtls("internal error\n");
						clearClient(dtlsCtx);
						clientCount--;
						break;
					}
					if (rc == MATRIXSSL_REQUEST_CLOSE) {
						psTraceDtls("Got REQUEST_CLOSE out of SentData\n");
						clearClient(dtlsCtx);
						clientCount--;
						break;
					}
					if (rc == MATRIXSSL_HANDSHAKE_COMPLETE) {
						/* This is the standard handshake case */
						psTraceDtls("Got HANDSHAKE_COMPLETE out of SentData\n");
						break;
					}
					/* SSL_REQUEST_SEND is handled by loop logic */
				}

			}
		}
	}
	return clientCount;
}
Exemplo n.º 15
0
/* draw the the AR objects */
static int draw(ObjectData_T *object, int objectnum)
{
	int     i;
	double  gl_para[16];

	glClearDepth(1.0);
	glClear(GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glEnable(GL_LIGHTING);

	/* calculate the viewing parameters - gl_para */

	int count = 0;
	
	float x1, x2,x3;
	float y1, y2,y3;
	float z1, z2,z3;


	for (i = 0; i < objectnum; i++) {
		if (object[i].visible == 0)continue;
		count++;
		argConvGlpara(object[i].trans, gl_para);
		draw_object(object[i].id, gl_para);
	}	


	x1 = object[0].trans[0][3], x2 = object[1].trans[0][3],x3 = object[2].trans[0][3];
	y1 = object[0].trans[1][3], y2 = object[1].trans[1][3], y3 = object[2].trans[1][3];
	z1 = object[0].trans[2][3], z2 = object[1].trans[2][3], z3 = object[2].trans[2][3];

	int grid = object[0].visible && object[1].visible;

	if (grid == 1){

		distX = fabs(x2 - x1);
		distY = fabs(y2 - y1);
		distZ = fabs(z2 - z1);

		//printf("grid distance %f %f %f \n ", distX, distY, distZ);
	}
	int controler =  object[2].visible;
	if (object[0].visible && controler){
		distX1 = fabs(x3 - x1);
		distY1 = fabs(y3 - y1);

		distX0 = fabs(x3 - x2);
		 distY0 = fabs(y3 - y2);
	}

	if (nFrame++ == 50) {
		nFrame = 0;

		if (controler){

			//calculate distance
			//printf("object id = %d ||  x = %f    || y =  %f     ||  z =  %f    ||\n", object[0].id, x1, y1, z1);
			//printf("object id = %d ||  x = %f    || y =  %f     ||  z =  %f    ||\n", object[1].id, x2, y2, z2);
			//printf("object id = %d ||  x = %f    || y =  %f     ||  z =  %f    ||\n", object[2].id, x3, y3, z3);

			printf(" distancia  0 - - 1    x = %f    || y =  %f     ||  z =  %f    ||\n", distX, distY, distZ);
			printf(" distancia  0-2 0-1 ||  x = %f  - - %f   || y =  %f - - %f       ||\n", distX1,distX0 ,  distY1, distY0);

			double x_send = distX1 / distX;
			double y_send = distY1 / distY;

			printf(" distancia norma   x = %f    || y =  %f    \n", x_send, y_send);
			
			/*
			// treat overflow
			if (x_send < 0.0)
				x_send = 0.0;
			else{
				if (y_send < 0.0)
					y_send = 0.0;
				else{
					if (x_send > 1.0)
						x_send = 1.0;
					else{
						if (y_send > 1.0)
							y_send = 1.0;
					}
				}
			}
			*/
			//printf(" distancia  normalizada   x = %f    || y =  %f    ||\n", x_send, y_send);

          	prepare_msg(x_send, y_send);

			udpSend(buf2);

			// if relevante change in distance then udpSend
		}
	}



	glDisable(GL_LIGHTING);
	glDisable(GL_DEPTH_TEST);
	return(0);
}
Exemplo n.º 16
0
int main(int argc, char **argv)
{
    int   i;
    int   iRet = 0;
    int   iBufLen = 0;
    char    sMsgInBuf[MSQ_MSG_SIZE_MAX];
    char    sMsgOutBuf[MSQ_MSG_SIZE_MAX];
    int     nMsgInLen=0;
    int     nIntMsgLen=0;
    int     nMsgOutLen=0;

    /* 进程初始化 */
    iRet = MonSrvInit(argc, argv);
    if (iRet != 0)
    {
        HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "MonSrv Init  err ");
        DbsDisconnect ();
        exit(-1);
    }

    /*设置信号处理*/
    if ( sigset(SIGTERM, ShutDown_Main) == SIG_ERR)
    {
        HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, 
                "sigset SIGTERM error, %d.", errno);
        DbsDisconnect ();        
        exit(-2);
    }

    HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "[%s] start", gsSrvId);
    
    /*初始化socket*/
    if( (gUpdSocket=udpConnectSocket())==-1 )
    {
    	  HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "init socket error %d", gUpdSocket);
        DbsDisconnect ();
        exit(-3);
    }
    
    for (; ;)
    {
           memset(sMsgInBuf, 0, sizeof(sMsgInBuf));
       
           sigrelse (SIGTERM);
           HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, 
                  "recv begin[%s][%d][%d][%4.4s]",gsSrvId,gatSrvMsq[0].nMsqId,gatSrvMsq[0].lMsqType,gatSrvMsq[0].sSrvId);
           /* 从消息队列中获取消息 */
           nMsgInLen = MSQ_MSG_SIZE_MAX;
           iRet = MsqRcv (gsSrvId, gatSrvMsq, 0, MSQ_RCV_MODE_BLOCK, &nMsgInLen, sMsgInBuf);
           sighold (SIGTERM);
           if (iRet != 0)
           {
               if (iRet != ERR_CODE_MSQ_BASE + EINTR)
               {
                    HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "MsqRcv error %d", iRet);
                    CloseSocket(gUpdSocket);
                    DbsDisconnect ();
                    exit(-4);
               }
               else
               {
               	   HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "MsqRcv error %d", iRet);
                   continue;
               }
           }
       
           HtDebugString(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, sMsgInBuf, nMsgInLen);
            
           memset(&ptIpcIntTxn, 0, sizeof(T_IpcIntTxnDef));
           memcpy(&ptIpcIntTxn,sMsgInBuf, nMsgInLen);
           memset(&ptTxn,0x00,sizeof(Tbl_txn_Def));
           
           iRet = MonMoveIpc2Txn(&ptIpcIntTxn, &ptTxn );
           if( iRet != 0 )
           {
               HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "MoveIpc2Txn error %d", iRet); 
               continue;   
           }  
           HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "InsertDayMoni begin "); 
           iRet= InsertDayMoni(&ptTxn);
           if( iRet )
           {
           	  HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "insert tbl_day_trans_monitor error");
           }
           
           HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "WriteTnx2File begin "); 
           iRet=WriteTxn2File(gsMoniTxnFile,&ptTxn);
           if(iRet != 0 )
           {
           	    HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "WriteTnx2File error %d", iRet); 
                continue;   
           }
           HtLog (gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "udpSend begin "); 
           /* 把通知报文发送给监控系统 */
           memset(sMsgOutBuf,0x00,sizeof(sMsgOutBuf));
           nMsgOutLen = sizeof(Tbl_txn_Def);               
           sprintf(sMsgOutBuf,"%04d",nMsgOutLen);
           memcpy (sMsgOutBuf+4,(char *)&ptTxn, nMsgOutLen);
           nMsgOutLen =nMsgOutLen+4;
           
           sigset(SIGALRM, sTimeOut);
           
           alarm(60);
	         iRet = udpSend(gUpdSocket, gsRmtIp, gUdpPort,sMsgOutBuf,nMsgOutLen);
	         alarm(0);
	         if( iRet == 0 )
	         {
	   	              HtLog( gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__,
	   		               "send to gsRmtIp[%s]: gUdpPort[%d] ok",gsRmtIp, gUdpPort,iRet );
	         }
	         else
	         {    
	   	           if (errno != EINTR)
	   	           {
	   	           	  HtLog( gsLogFile, HT_LOG_MODE_ERROR, __FILE__,__LINE__, "send to %s:%d error,errno=%d,%s",
	   		                gsRmtIp, gUdpPort,errno,strerror(errno));
	   		            CloseSocket(gUpdSocket);
	   	   	          exit(-5);
	   	   	          DbsDisconnect ();
	   	           }
	         }
           
    }
    CloseSocket(gUpdSocket);
    DbsDisconnect ();
    return 0;
} /* main end */