MQTT-C-UDP_PUB

/**

******************************************************************************

* @file apdu.c

* @author ding

* @version V1.0.0

* @date 2016-10-25

* @brief This file provides all the decode or encode functions.

******************************************************************************

* @attention

*

* FIX ME.

*

* <h2><center>© COPYRIGHT 2016 THIT</center></h2>

******************************************************************************

*/

/** @mainpage

* 

* <CENTER>CRRC Information Technology Co.,Ltd</CENTER>

* 

* 

* <CENTER>Automatic Test Equipment</CENTER>

* 

* 

*<hr/>

*   

*This documents the automatic test equipment API and sample applications.

*<hr/>

* 

* 

* <CENTER>Advanced Research Institute</CENTER>

* 

* 

* 

* <CENTER>Advanced Research Institute</CENTER>

* <CENTER>Mu HongWei</CENTER>

* <CENTER>2016-10-25</CENTER>

*<CENTER><a href="http://www.thit.com.cn/">Welcome To Visit THIT</a></CENTER>

* 

* 

*/

/* Includes ------------------------------------------------------------------*/

#include "encode.h"

#include <stdio.h>

#include <stdlib.h>

#include "sent_request.h"

#include "sent_ack.h"

#include "sent_error.h"

#include "sent_apdu.h"

#include "request_handler.h"

#include "tcp_setup.h"

#include "decrypt.h"

#include <sys/stat.h>

//#include <sys/time.h> /* CLOCK_MONOTONIC */

#include <time.h> /* clock_gettime() CLOCK_MONOTONIC*/

#include <termios.h> /* struct termios */

#include <string.h> /* strcasecmp() */

#include <unistd.h> /* usleep() */

#include <arpa/inet.h> /* htons() */

#include <pthread.h>

//---------------------------------------------

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

///////////////////////////////////////////////////////----------------------MQTT-------------------------///////////////////////////////////////////////////////////////////////////////////////////////////////

/* This provides a crude manner of testing the performance of a broker in messages/s. */

#include <stdbool.h>

#include <stdint.h>

//#include <stdio.h>

#include <sys/time.h>

#include <mosquitto.h>

#include<mosquitto_internal.h>

#include "msgsps_common.h"

#include<time.h>

#include <string.h>

static unsigned char heart_num;

static bool run = true;

static int message_count = 0;

static struct timeval start, stop;

//static struct mosquitto *mosq;

//static char *buf123="0123456789";

//static unsigned int mqtt_num =0;

//static unsigned int message_count=0;

//-----------------------------------------------------------------------

static unsigned int ip_addr;

static unsigned short int port;

//------------------------------------------------------------------------

/*

============================================================================

Name : mqtest.c

Author :

Version :

Copyright : Your copyright notice

Description : Hello World in C, Ansi-style

============================================================================

*/

#include <stdio.h>

#include <stdlib.h>

#include <mosquitto.h>

#include <string.h>
static int x =1;

/*static lgt*/ struct mosquitto *mosq = NULL;

int i_count=0;//lgt

void my_message_callback(struct mosquitto *mosq, void *userdata, const struct mosquitto_message *message)

{

 if(message->payloadlen){

 printf("%s %s ", message->topic, message->payload);

 }else{

 printf("%s (null) ", message->topic);

 }

 fflush(stdout);

}

void my_connect_callback(struct mosquitto *mosq, void *userdata, int result)

{

 int i;

 if(!result){

 mosquitto_subscribe(mosq, NULL, "mqtt-test-queue", 2);

 /*mosquitto_publish(mosq,NULL,"lgt")*/

 /*int payloadlen, const void *payload, int qos, bool retain*/

 }else{

 fprintf(stderr, "Connect failed ");

 }

}

void my_subscribe_callback(struct mosquitto *mosq, void *userdata, int mid, int qos_count, const int *granted_qos)

{

 int i;

 printf("Subscribed (mid: %d): %d", mid, granted_qos[0]);

 for(i=1; i<qos_count; i++){

 printf(", %d", granted_qos[i]);

 }

 printf(" ");

}

void my_log_callback(struct mosquitto *mosq, void *userdata, int level, const char *str)

{

 /* Pring all log messages regardless of level.*/

 printf("%s ", str);

}

 static void MQTT_topic_data(unsigned char *data,int data_len)

 {

 //puts("!!!Hello World!!!");

//* prints !!!Hello World!!!
 printf(" data-----------------------------------------------------MQTT----------------------------------------------------------------- ");



 char dst1[20];

 unsigned int i;

 unsigned char str[1024];

 unsigned char dst[1024];

 for(i=0;i<data_len;i++)

 {

 str[2*i] = data[i] >>4;

 str[2*i+1] = data[i] & 0xf;

 }

 for(i=0;i<2*data_len;i++)

 {

 sprintf(&dst[i],"%X/n",str[i]);

 printf("%c ",dst[i]);

 }



 i_count++;

 sprintf(dst1, "%d", i_count);

 /**ddd=strcat(dst, dst1);*/

 //dst1=dst;

 //if (data_len>0)

 // {

 mosquitto_publish(mosq, NULL, "topic-from-kenya",2*data_len, dst, 0, true);

 // }

 // {

 //mosquitto_publish(mosq, NULL, "mqtt-test-queue",strlen(dst1), dst1, 0, true);
 // sleep(1);

 // }

 }



///////////////////////////////////////////////////////////////////--------------------MQTT-TAIL---------------------------//////////////////////////////////////////////////////////////////////////////////////////////////////

//static struct circ_buf recv_queue = {PTHREAD_MUTEX_INITIALIZER, 0, 0};

static packet_info recv_packet[TRAIN_TOTAL];

static int cmp_addr(struct sockaddr_in dest, struct sockaddr_in src)

{

//-----------------------------------------------

 ip_addr=src.sin_addr.s_addr;

 port =src.sin_port;

 //----------------------------------------------

char dst[1000];

//-----------------------------------------------

// printf("dest addr: %d--%d--%d ", dest.sin_family, dest.sin_addr.s_addr, dest.sin_port);



// printf("src addr: %d--%d--%d ", src.sin_family, src.sin_addr.s_addr, src.sin_port);

//-----------------------------------------------------

if((inet_ntop(AF_INET,&src.sin_addr.s_addr,dst,sizeof(dst)))==NULL)

 printf("inet_ntop ");

 printf("dst=%s,sizeof(dst)=%d ",dst,sizeof(dst));

//------------------------------------------------------

 if ((dest.sin_family != src.sin_family) || (dest.sin_addr.s_addr != src.sin_addr.s_addr) || (dest.sin_port != src.sin_port))

 return -1;

 else

 return 0;

}

static void int_packet(void)

{

 int i;

 for (i = 0; i < TRAIN_TOTAL; i++) {

 memset(&(recv_packet[i].dout), '', sizeof(struct sockaddr_in));

 recv_packet[i].packet_total = 0;

 recv_packet[i].state = 0;

 }

}

static int set_packet_total(struct sockaddr_in addr)

{

 int i;

 for (i = 0; i < TRAIN_TOTAL; i++) {

 if ((cmp_addr(recv_packet[i].dout, addr) == 0) && (recv_packet[i].state == 1)) {

 recv_packet[i].packet_total++;

 printf("find sockaddr_in! ");

 return 1;

 }

 }

 for (i = 0; i < TRAIN_TOTAL; i++) {

 if (recv_packet[i].state == 0) {

 //memcpy(&(recv_packet[i].dout), &addr, sizeof(struct sockaddr_in));

 recv_packet[i].dout.sin_family = addr.sin_family;

 recv_packet[i].dout.sin_addr.s_addr = addr.sin_addr.s_addr;

 recv_packet[i].dout.sin_port = addr.sin_port;

 recv_packet[i].packet_total = 1;

 recv_packet[i].state = 1;

 // printf("dest port: %d, src port: %d ", recv_packet[i].dout.sin_port, addr.sin_port);

 printf("can't find sockaddr_in! ");

 return 2;

 }

 }

 printf("find sockaddr_in fail! ");

 return -1;

}

static unsigned int get_packet_total(struct sockaddr_in addr)

{

 int i;

 for (i = 0; i < TRAIN_TOTAL; i++) {

 if ((cmp_addr(recv_packet[i].dout, addr) == 0) && (recv_packet[i].state == 1)) {

 printf("packet total: %d ", recv_packet[i].packet_total);

 return recv_packet[i].packet_total;

 }

 }

 return -1;

}

/** @defgroup APDU

* @brief decode and encode APDU modules

* @{

*/

/** @defgroup APDU_Defines

* @{

*/

#if 0

#define MY_BIG_ENDIAN 1 /* crd8362 test */

#define COM1 0

#define COM2 1

#define COM_BUF_LEN 30

/**

* @}

*/

static request_function request_handler[CMD_MAX - 1];

static ack_function ack_handler[CMD_MAX - 1];

static error_function error_handler[CMD_MAX - 1];

/** @defgroup APDU_Pubilc_Functions

* @{

*/

/** Set request handler function.

*

*

* @param number [in] .

* @param pFunction [in] .

*/

void set_request_handler(CMD number, request_function p_function)

{

 if ((number > 0) && (number < CMD_MAX))

 request_handler[number - 1] = p_function;

}

/** Set ack handler function.

*

*

* @param number [in] .

* @param pFunction [in] .

*/

void set_ack_handler(CMD number, request_function p_function)

{

 if ((number > 0) && (number < CMD_MAX))

 ack_handler[number - 1] = p_function;

}

/** Set error handler function.

*

*

* @param number [in] .

* @param pFunction [in] .

*/

void set_error_handler(CMD number, request_function p_function)

{

 if ((number > 0) && (number < CMD_MAX))

 error_handler[number - 1] = p_function;

}

#endif

/**

* @}

*/

/** @defgroup APDU_ENCODE

* @{

*/

/** Encode short functions.

*

*

* @param value [in] .

* @param buf [out] .

* @return the number of buf octets, or 0 on failure.

*/

#if 0

static int encode_short_into_buffer(unsigned short value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 buf[0] = (unsigned char)((value & 0xff00) >> 8);

 buf[1] = (unsigned char)(value & 0x00ff);

 return 2;

}

static int encode_int_into_buffer(unsigned int value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 buf[0] = (unsigned char) ((value & 0xff000000) >> 24);

 buf[1] = (unsigned char) ((value & 0x00ff0000) >> 16);

 buf[2] = (unsigned char) ((value & 0x0000ff00) >> 8);

 buf[3] = (unsigned char) (value & 0x000000ff);

 return 4;

}

#endif

#if 0

static int encode_float_into_buffer(float value, unsigned char *buf)

{

 union {

 unsigned char byte[4];

 float real_value;

 } my_data;



 if (buf == NULL)

 return 0;

 my_data.real_value = value;

#if MY_BIG_ENDIAN

 buf[0] = my_data.byte[0];

 buf[1] = my_data.byte[1];

 buf[2] = my_data.byte[2];

 buf[3] = my_data.byte[3];

#else

 buf[0] = my_data.byte[3];

 buf[1] = my_data.byte[2];

 buf[2] = my_data.byte[1];

 buf[3] = my_data.byte[0];

#endif

 return 4;

}

static int encode_channel(channel_data_function value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 buf[0] = value.first_channel;

 buf[1] = value.channel_num;

 return 2;

}

static int encode_uart(uart_data_function value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 buf[0] = value.uart_index;

 buf[1] = value.board_addr;

 encode_short_into_buffer(value.reg_addr, &buf[2]);

 buf[4] = value.reg_num;

 return 5;

}

static int encode_test_com(com_test_data_function value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 buf[0] = value.from_com;

 buf[1] = value.to_com;

 return 2;

}

static int encode_multiple_float(unsigned short num, float *value, unsigned char *buf)

{

 unsigned short i, encode_len = 0;



 if ((value == NULL) || (buf == NULL))

 return 0;

 for (i = 0; i < num; i++) {

 encode_len += encode_float_into_buffer(*value, &buf[encode_len]);

 value++;

 }

 return encode_len;

}

#endif

static unsigned short update_crc_ccitt(unsigned short crc, char c)

{

 unsigned short q;

 int j;



 for (j = 0; j < 8; j++) {

 q = (crc & 0x0001) ^ (c & 0x0001);

 if (q == 0x0001) {

 crc = crc >> 1;

 crc = crc ^ 0x8408;

 } else

 crc = crc >> 1;

 c = c >> 1;

 }

 return crc;

}

static unsigned short calc_crc(char *str, int len)

{

 unsigned short crc_ccitt/*, low_byte, high_byte*/;

 int i;

 crc_ccitt = 0xffff;

 i = 0;

 while (i < len) {

 crc_ccitt = update_crc_ccitt(crc_ccitt, str[i]);

 i++;

 }

 return crc_ccitt;

}

/**

* @}

*/

/** Decode

*

*/

/** @defgroup APDU_DECODE

* @{

*/

int decode_short_from_buffer(unsigned short *value, const unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 *value = ((unsigned short)buf[0] << 8) & 0xff00;

 *value |= (unsigned short)buf[1] & 0x00ff;

 return 2;

}

#if 0

static int decode_int_from_buffer(unsigned int *value, unsigned char *buf)

{

 if (buf == NULL)

 return 0;

 if (value) {

 *value = ((unsigned int) ((((unsigned int) buf [0]) << 24) & 0xff000000));

 *value |= ((unsigned int) ((((unsigned int) buf [1]) << 16) & 0x00ff0000));

 *value |= ((unsigned int) ((((unsigned int) buf [2]) << 8) & 0x0000ff00));

 *value |= ((unsigned int) (((unsigned int) buf [3]) & 0x000000ff));

 return 4;

 } else

 return 0;

}

#endif

static int decode_float_from_buffer(float *value, const unsigned char *buf)

{

 union {

 unsigned char byte[4];

 float real_value;

 } my_data;



 if ((buf == NULL) || (value ==NULL))

 return 0;

#if MY_BIG_ENDIAN

 my_data.byte[0] = buf[0];

 my_data.byte[1] = buf[1];

 my_data.byte[2] = buf[2];

 my_data.byte[3] = buf[3];

#else

 my_data.byte[0] = buf[3];

 my_data.byte[1] = buf[2];

 my_data.byte[2] = buf[1];

 my_data.byte[3] = buf[0];

#endif

 *value = my_data.real_value;

 return 4;

}

int decode_multiple_float(unsigned short num, float *value, const unsigned char *buf)

{

 unsigned short i, encode_len = 0;



 if ((value == NULL) || (buf == NULL))

 return 0;

 for (i = 0; i < num; i++) {

 encode_len += decode_float_from_buffer(value, &buf[encode_len]);

 value++;

 }

 return encode_len;

}

static int decode_head(head_s *recv_head, const unsigned char *buf, int len)

{

 int value = -1;



 if (len < HEAD_LEN)

 return value;

 if (buf[HEAD_TPYE_INDEX] != APDU_TYPE_REQUEST && buf[HEAD_TPYE_INDEX] != APDU_TYPE_ACK)

 return value;

 else {

 recv_head->type = buf[HEAD_TPYE_INDEX];

 value = (int)buf[HEAD_TPYE_INDEX];

 }

 recv_head->device = (unsigned int)buf[HEAD_DEVICE_INDEX];

 recv_head->device = (recv_head->device << 8) | (unsigned int)buf[HEAD_DEVICE_INDEX + 1];

 recv_head->device = (recv_head->device << 8) | (unsigned int)buf[HEAD_DEVICE_INDEX + 2];

 if (buf[HEAD_NUM_INDEX] != 0x01) {

 value = -2;

 return value;

 } else

 recv_head->index = buf[HEAD_NUM_INDEX];

 recv_head->message = buf[HEAD_MESSAGE_INDEX];

 recv_head->host = buf[HEAD_HOST_ID_INDEX];

 decode_short_from_buffer(&recv_head->port, &buf[HEAD_PORT_INDEX]);

 if (buf[HEAD_NETGATE_INDEX] != 0x00) {

 value = -3;

 return value;

 } else

 recv_head->netgate = buf[HEAD_NETGATE_INDEX];

 return value;

}

static int decode_train_num(unsigned char *train_num, unsigned char *buf, int len)

{

 int i, value = -1;

 if (len < TRAIN_NUM_LEN)

 return value;

 //memcpy(train_num, buf, TRAIN_NUM_LEN);

 printf("train num:");

 for(i = 0; i < TRAIN_NUM_LEN; i++) {

 train_num[i] = buf[i];

 printf("%02x ", buf[i]);

 }

 printf(" ");

 value = TRAIN_NUM_LEN;



 return value;

}

static int decode_message_id(unsigned short *message_id, unsigned char *buf, int len)

{

 int value = -1;

 if (len < MESSAGE_ID_LEN)

 return value;

 decode_short_from_buffer(message_id, buf);

 value = 2;

 printf("message id: %02x ", *message_id);

 return value;

}

static int check_message_id(unsigned short message_id)

{

 int value = -1;



 switch (message_id) {

 case CMD_RECV_WORK_MESSAGE:

 case CMD_RECV_RECONNECT_MESSAGE:

 case CMD_RECV_FEEDBACK_MESSAGE:

 case CMD_RECV_CONFIG_MESSAGE:

 case CMD_RECV_RECONNECT_FAULT:

 case CMD_RECV_RECONNECT_TOTAL:

 case CMD_RECV_ID_VERIFICATION:

 case CMD_RECV_HEARTBEAT:

 value = 1;

 break;

 default:

 break;

 }

 return value;

}

static int check_crc(const unsigned char *head, const unsigned char *buf, int len)

{

 int value = -1;

 unsigned short packet_len, temp_crc, recv_crc;



 if ((len < PACKET_LENGTH_LEN) || (head == NULL) || (buf == NULL)) {

 printf("len is %d ", len);

 return value;

 }



 decode_short_from_buffer(&packet_len, buf);

 if (packet_len > len) {

 printf("packet_len is %d ", packet_len);

 return value;

 }



 //temp_crc = calc_crc(buf, len - TAIL_LEN);

 if(len<6)

 temp_crc = calc_crc(head, packet_len + HEAD_LEN + TRAIN_NUM_LEN);

 else

 temp_crc = calc_crc(head, packet_len + HEAD_LEN+ 6 + TRAIN_NUM_LEN);



 decode_short_from_buffer(&recv_crc, &buf[packet_len - TAIL_LEN]);

 printf("crc buf: %02x %02x ", buf[packet_len - TAIL_LEN], buf[packet_len - TAIL_LEN + 1]);

 printf("packet_len: %d recv crc: %04x calc crc: %04x ", packet_len, recv_crc, temp_crc);

 if (temp_crc == recv_crc)

 value = 1;



 return value;

// return 1;

}

static int sent_heartbeat(unsigned int device, unsigned char num, int socket_fd, struct sockaddr_in dout)

{

 unsigned char temp[17];

 unsigned short crc;

 temp[0] = 0x30;

 temp[1] = (unsigned char)(device >> 16 & 0x000000ff);

 temp[2] = (unsigned char)(device >> 8 & 0x000000ff);

 temp[3] = (unsigned char)(device & 0x000000ff);

 temp[4] = 0x01;

 temp[5] = 0x00;

 temp[6] = 0x6A;

 temp[7] = 0x1A;

 temp[8] = 0x85;

 temp[9] = 0x00;

 temp[10] = 0x10;

 temp[11] = 0x00;

 temp[12] = 0x00;

 temp[13] = 0x05;

 temp[14] = num;

 crc = calc_crc(temp, 15);

 temp[15] = (unsigned char)(crc >> 8);

 temp[16] = (unsigned char)(crc & 0x00ff);

 return tcp_sent(socket_fd, temp, 17, dout);

}

static void recv_handler(head_s head, unsigned short message_id, const unsigned char *data, int data_len, int socket_fd, struct sockaddr_in dout)

{

 switch (message_id) {

 case CMD_RECV_WORK_MESSAGE:

 break;

 case CMD_RECV_RECONNECT_MESSAGE:

 break;

 case CMD_RECV_FEEDBACK_MESSAGE:

 break;

 case CMD_RECV_CONFIG_MESSAGE:

 break;

 case CMD_RECV_RECONNECT_FAULT:

 break;

 case CMD_RECV_RECONNECT_TOTAL:

 break;

 case CMD_RECV_ID_VERIFICATION:

 break;

 case CMD_RECV_HEARTBEAT:

 sent_heartbeat(head.device, data[21], socket_fd, dout);

 break;

 default:

 break;

 }

}

static char* get_data_time(void)

{

 static char now_time[20];

 time_t raw_time;

 struct tm* l_time;



 time(&raw_time);

 l_time = localtime(&raw_time);

 strftime(now_time, 20, "%Y-%m-%d %H:%M:%S", l_time);

 return now_time;

}

static char *dir = "./log";

static char *file_name = "/message.log";

static char* create_train_dir(char *p)

{

 static char train_dir[50];

 char temp[30];

 int i;

 if (p == NULL)

 return NULL;

 memset(train_dir, '', sizeof(train_dir));

 memset(temp, '', sizeof(temp));

 //if (NULL == opendir(dir)) {

 if (access(dir, F_OK) != 0) {

 if (mkdir(dir, 0755) == -1) {

 perror("mkdir error");

 return NULL;

 }

 }

 for (i = 0; i < TRAIN_NUM_LEN; i++) {

 if (p[i] == '')

 temp[i] = '_';

 else

 temp[i] = p[i];

 }

 strcpy(train_dir, dir);

 strcat(train_dir, "/");

 strcat(train_dir, temp);

 if(access(train_dir, F_OK) != 0) {

 if(mkdir(train_dir, 0755) == -1) {

 perror("mkdir error");

 return NULL;

 }

 }

 printf("%s ", temp);

 printf("%s ", train_dir);

 return train_dir;

}

static int write_head(FILE *p, head_s h_data)

{

 if (p == NULL)

 return -1;

 fprintf(p, "head: type=0x%02x device=%d index=%d message=%d host=%d port=%d netgate=%d ", h_data.type, h_data.device, h_data.index, h_data.message, h_data.host, h_data.port, h_data.netgate);

 return 1;

}

static int write_message_id(FILE *p, unsigned short message_id)

{

 if (p == NULL)

 return -1;

 fprintf(p, "message id: 0x%04x ", message_id);

 return 1;

}

#if 0

static void disp_temperature(FILE *p, unsigned char data)

{

 char temp;

 temp = data;

 if (data == 0x81)

 fprintf(p, "error ");

 else if (data == 0x82)

 fprintf(p, "none ");

 else

 fprintf(p, "%d ", (int)temp);

}

#endif

static int write_work_body(FILE *p, unsigned char *data, int len)

{

 int i;

 char t_num[T_NUM_LEN + 1];

 char temp;

 //bearing_s bearing_data[7];

 //alarm_data_s alarm_data;

 //status_s status_data;

 gps_s gps_data;

 char now_time[20];

 //char train_info[TRAIN_INFO_LIN + 1];

 time_t raw_time;

 unsigned int recv_time;

 struct tm* l_time;

 int c_len;

 if ((p == NULL) || (data == NULL))

 return -1;

 if (len < WORK_LEN) {

 fprintf(p, "data error, len is: %d less than %d ", len, WORK_LEN);

 return -2;

 }

 memset(t_num, '', sizeof(t_num));

 memcpy(t_num, &data[2], T_NUM_LEN);

 fprintf(p, "train num:%s ", t_num);

 temp = data[2 + T_NUM_LEN + RESERVE_LEN];

 fprintf(p, "temperature_env1=%d ", (int)temp);

 temp = data[2 + T_NUM_LEN + RESERVE_LEN + 1];

 fprintf(p, "temperature_env2=%d ", (int)temp);

 temp = data[2 + T_NUM_LEN + RESERVE_LEN + 2];

 fprintf(p, "temperature_main_generator=%d ", (int)temp);

 temp = data[2 + T_NUM_LEN + RESERVE_LEN + 3];

 fprintf(p, "temperature_fan1=%d ", (int)temp);

 temp = data[2 + T_NUM_LEN + RESERVE_LEN + 4];

 fprintf(p, "temperature_fan2=%d ", (int)temp);

 c_len = 2 + T_NUM_LEN + RESERVE_LEN + OTHER_TEMPERATURE_LEN;

 for (i = 0; i < 6; i++) {

 fprintf(p, "bearing %d data: ", i + 1);

 temp = data[c_len + i * 6 + 0];

 fprintf(p, "temperature_1=%d ", (int)temp);

 temp = data[c_len + i * 6 + 1];

 fprintf(p, "temperature_2=%d ", (int)temp);

 temp = data[c_len + i * 6 + 2];

 fprintf(p, "temperature_3=%d ", (int)temp);

 temp = data[c_len + i * 6 + 3];

 fprintf(p, "temperature_4=%d ", (int)temp);

 temp = data[c_len + i * 6 + 4];

 fprintf(p, "temperature_5=%d ", (int)temp);

 temp = data[c_len + i * 6 + 5];

 fprintf(p, "temperature_6=%d ", (int)temp);

 }

 c_len = 2 + T_NUM_LEN + RESERVE_LEN + OTHER_TEMPERATURE_LEN + TEMPERATURE_LEN;

 temp = data[c_len];

 fprintf(p, "alarm data: ");

 fprintf(p, "temperature_max=%d ", (int)temp);

 fprintf(p, "max_num=%d ", (int)data[c_len + 1]);

 fprintf(p, "alarm_identifier=%d ", (int)data[c_len + 2]);

 fprintf(p, "current_alarm_num=%d ", (int)data[c_len + 3]);

 recv_time = (unsigned int)data[c_len + 4];

 recv_time = (recv_time << 8) | (unsigned int)data[c_len + 5];

 recv_time = (recv_time << 8) | (unsigned int)data[c_len + 6];

 recv_time = (recv_time << 8) | (unsigned int)data[c_len + 7];

 raw_time = (time_t)recv_time;

 l_time = localtime(&raw_time);

 strftime(now_time, 20, "%Y-%m-%d %H:%M:%S", l_time);

 fprintf(p, "alarm_time=%s ", now_time);

 fprintf(p, "alarm_code=%d ", (int)data[c_len + 8]);

 temp = data[c_len + 9];

 fprintf(p, "alarm_test_temperature=%d ", (int)temp);

 temp = data[c_len + 10];

 fprintf(p, "alarm_temperature_ref=%d ", (int)temp);

 c_len = 2 + T_NUM_LEN + RESERVE_LEN + OTHER_TEMPERATURE_LEN + TEMPERATURE_LEN + ALARM_LEN + OTHER_LEN;

 fprintf(p, "gps_data: ");

 decode_float_from_buffer(&gps_data.east, &data[c_len]);

 fprintf(p, "gps_east=%f ", gps_data.east);

 fprintf(p, "gps_east_minute=%d ", (int)data[c_len + 4]);

 decode_float_from_buffer(&gps_data.north, &data[c_len + 5]);

 fprintf(p, "gps_north=%f ", gps_data.north);

 fprintf(p, "gps_north_minute=%d ", (int)data[c_len + 9]);

 gps_data.speed = data[c_len + 10];

 fprintf(p, "gps_speed=%d ", (int)gps_data.speed);

 fprintf(p, " ");

 return 1;

}

static int write_reconnect_message(FILE *p, unsigned char *data, int len)

{

 int i;

 unsigned short temp;

 short temp_t;

 unsigned int recv_time;

 char now_time[20];

 time_t raw_time;

 struct tm* l_time;

 gps_s gps_data;

 int c_len;



 if ((p == NULL) || (data == NULL))

 return -1;

 if (len < RECONNECT_MESSAGE_MAX) {

 fprintf(p, "data error, len is: %d less than %d ", len, RECONNECT_MESSAGE_MAX);

 return -2;

 }

 fprintf(p, "reconnect message data: ");

 for (i = 0; i < RECONNECT_MESSAGE; i = i + 2) {

 if (i < 82) {

 temp = (unsigned short)data[2 + i];

 temp = (temp << 8) | (unsigned short)data[2 + i + 1];

 fprintf(p, "(%d~%d)=%d ", i+1, i+2, (int)temp);

 } else if (i < 96) {

 if (i == 82)

 fprintf(p, " ");

 temp = (unsigned short)data[2 + i];

 temp = (temp << 8) | (unsigned short)data[2 + i + 1];

 temp_t = temp;

 fprintf(p, "(%d~%d)=%d ", i+1, i+2, (int)temp_t);

 } else if (i < 98){

 fprintf(p, " ");

 fprintf(p, "(%d)=0x%02x ", i+1, data[2 + i]);

 fprintf(p, "(%d)=0x%02x ", i+2, data[2 + i + 1]);

 } else if (i < 104) {

 temp = (unsigned short)data[2 + i];

 temp = (temp << 8) | (unsigned short)data[2 + i + 1];

 fprintf(p, "(%d~%d)=%d ", i+1, i+2, (int)temp);

 } else if (i == 104) {

 fprintf(p, " ");

 recv_time = (unsigned int)data[2 + i];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 1];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 2];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 3];

 raw_time = (time_t)recv_time;

 l_time = localtime(&raw_time);

 strftime(now_time, 20, "%Y-%m-%d %H:%M:%S", l_time);

 fprintf(p, "time=%s ", now_time);

 break;

 }

 }

 c_len = 2 + RECONNECT_MESSAGE;

 fprintf(p, "gps_data: ");

 decode_float_from_buffer(&gps_data.east, &data[c_len]);

 fprintf(p, "gps_east=%f ", gps_data.east);

 fprintf(p, "gps_east_minute=%d ", (int)data[c_len + 4]);

 decode_float_from_buffer(&gps_data.north, &data[c_len + 5]);

 fprintf(p, "gps_north=%f ", gps_data.north);

 fprintf(p, "gps_north_minute=%d ", (int)data[c_len + 9]);

 gps_data.speed = data[c_len + 10];

 fprintf(p, "gps_speed=%d ", (int)gps_data.speed);

 fprintf(p, " ");

 return 1;

}

static int write_reconnect_fault(FILE *p, unsigned char *data, int len)

{

 int i;

 //unsigned short train_num, ticket_num;

 unsigned int recv_time;

 char now_time[20];

 time_t raw_time;

 struct tm* l_time;

 int c_len;

 gps_s gps_data;



 if ((p == NULL) || (data == NULL))

 return -1;

 if (len < RECONNECT_FAULT_MAX) {

 fprintf(p, "data error, len is: %d less than %d ", len, RECONNECT_FAULT_MAX);

 return -2;

 }

 fprintf(p, "reconnect fault data: ");

 //train_num = (unsigned short)data[2];

 //train_num = (train_num << 8) | (unsigned short)data[3];

 //fprintf(p, "train_num=%d ", (int)train_num);

 //ticket_num = (unsigned short)data[4];

 //ticket_num = (ticket_num << 8) | (unsigned short)data[5];

 //fprintf(p, "ticket_num=%d ", (int)ticket_num);

 for (i = 0; i < RECONNECT_FAULT; i++) {

 if (i < 45) {

 if (data[2 + i] == 0xff)

 fprintf(p, "(%d)=fault ", i+1);

 else if (data[2 + i] == 0)

 fprintf(p, "(%d)=normal ", i+1);

 else

 fprintf(p, "(%d)=error ", i+1);

 } else if (i == 45) {

 fprintf(p, " ");

 recv_time = (unsigned int)data[2 + i];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 1];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 2];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + i + 3];

 raw_time = (time_t)recv_time;

 l_time = localtime(&raw_time);

 strftime(now_time, 20, "%Y-%m-%d %H:%M:%S", l_time);

 fprintf(p, "time=%s ", now_time);

 break;

 }

 }

 c_len = 2 + RECONNECT_FAULT;

 fprintf(p, "gps_data: ");

 decode_float_from_buffer(&gps_data.east, &data[c_len]);

 fprintf(p, "gps_east=%f ", gps_data.east);

 fprintf(p, "gps_east_minute=%d ", (int)data[c_len + 4]);

 decode_float_from_buffer(&gps_data.north, &data[c_len + 5]);

 fprintf(p, "gps_north=%f ", gps_data.north);

 fprintf(p, "gps_north_minute=%d ", (int)data[c_len + 9]);

 gps_data.speed = data[c_len + 10];

 fprintf(p, "gps_speed=%d ", (int)gps_data.speed);

 fprintf(p, " ");

 return 1;

}

static int write_reconnect_total(FILE *p, unsigned char *data, int len)

{

 int i;

 unsigned short temp;

 unsigned int recv_time, temp_32;

 char now_time[20];

 time_t raw_time;

 struct tm* l_time;

 int c_len;

 gps_s gps_data;



 if ((p == NULL) || (data == NULL))

 return -1;

 if (len < RECONNECT_TOTAL_MAX) {

 fprintf(p, "data error, len is: %d less than %d ", len, RECONNECT_TOTAL_MAX);

 return -2;

 }

 fprintf(p, "reconnect total data: ");

 fprintf(p, "protocol version=%.2f ", (float)data[2] / 10.0);

 fprintf(p, "software slave=%d ", (int)data[2 + 1]);

 fprintf(p, "software master=%d ", (int)data[2 + 2]);

 temp = (unsigned short)data[2 + 3];

 temp = (temp << 8) | (unsigned short)data[2 + 4];

 fprintf(p, "train_num=%d ", (int)temp);

 temp = (unsigned short)data[2 + 5];

 temp = (temp << 8) | (unsigned short)data[2 + 6];

 fprintf(p, "train_type=0x%02x ", (int)temp);

 if (data[2 + 7] == 0x01)

 fprintf(p, "A or B=A ");

 else if (data[2 + 7] == 0x02)

 fprintf(p, "A or B=B ");

 else if (data[2 + 7] == 0xff)

 fprintf(p, "A or B=none ");

 else

 fprintf(p, "A or B=error ");

 for (i = 0; i < 8; i++) {

 temp_32 = (unsigned int)data[2 + 8 + i * 4];

 temp_32 = (temp_32 << 8) | (unsigned int)data[2 + 9 + i * 4];

 temp_32 = (temp_32 << 8) | (unsigned int)data[2 + 10 + i * 4];

 temp_32 = (temp_32 << 8) | (unsigned int)data[2 + 11 + i * 4];

 fprintf(p, "(%d~%d)=%d ", 9 + i * 4, 12 + i * 4, temp_32);

 }

 fprintf(p, " ");

 recv_time = (unsigned int)data[2 + 45];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + 46];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + 47];

 recv_time = (recv_time << 8) | (unsigned int)data[2 + 48];

 raw_time = (time_t)recv_time;

 l_time = localtime(&raw_time);

 strftime(now_time, 20, "%Y-%m-%d %H:%M:%S", l_time);

 fprintf(p, "time=%s ", now_time);

 c_len = 2 + RECONNECT_TOTAL;

 fprintf(p, "gps_data: ");

 decode_float_from_buffer(&gps_data.east, &data[c_len]);

 fprintf(p, "gps_east=%f ", gps_data.east);

 fprintf(p, "gps_east_minute=%d ", (int)data[c_len + 4]);

 decode_float_from_buffer(&gps_data.north, &data[c_len + 5]);

 fprintf(p, "gps_north=%f ", gps_data.north);

 fprintf(p, "gps_north_minute=%d ", (int)data[c_len + 9]);

 gps_data.speed = data[c_len + 10];

 fprintf(p, "gps_speed=%d ", (int)gps_data.speed);

 fprintf(p, " ");

 return 1;

}

#define NUM_PER_LINE 20

static int write_body(FILE *p, unsigned char *data, int len, unsigned short message_id)

{

 int i, j, line;

// data++;

// data++;

 unsigned char * data1;

 data1=data+0x02;



 if ((p == NULL) || (data == NULL))

 return -1;

 switch (message_id) {

 case CMD_RECV_WORK_MESSAGE:

 return write_work_body(p, data, len);

 //break;

 case CMD_RECV_RECONNECT_MESSAGE:

 return write_reconnect_message(p, data, len);

 //break;

 case CMD_RECV_FEEDBACK_MESSAGE:

 break;

 case CMD_RECV_CONFIG_MESSAGE:

 break;

 case CMD_RECV_RECONNECT_FAULT:

 return write_reconnect_fault(p, data, len);

 //break;

 case CMD_RECV_RECONNECT_TOTAL:

 return write_reconnect_total(p, data, len);

 //break;

 case CMD_RECV_ID_VERIFICATION:

 break;

 case CMD_RECV_HEARTBEAT:

 break;

 default:

 printf("error!! unrecognized message id! ");

 return -2;

 //break;

 }

#if 1

// if (len <= 0) {

// return 2;

// }

 fprintf(p, "data1:");



 line = len / NUM_PER_LINE;

 if ((len % NUM_PER_LINE) != 0)

 line += 1;



 for (j = 0; j < line - 1; j++) {

 for (i = 0; i < NUM_PER_LINE; i++)

 fprintf(p, " 0x%02x", data[i]);

 fprintf(p, " ");

 }

 for (j = j * NUM_PER_LINE; j < len; j++)

 fprintf(p, " 0x%02x", data[j]);

 fprintf(p, " ");

 return 1;

#endif

}

static int write_message_to_file(char *train_dir, char *file_name, head_s h_data, unsigned short message_id, unsigned char *data, int len, unsigned int total)

{

 char file_path[100];

 FILE *file_p;

 static unsigned int packet_num;

 static unsigned int current_packet_num;

 static unsigned int pre_packet_num;

 current_packet_num = total;

 if (pre_packet_num<=current_packet_num)

 {



 pre_packet_num=current_packet_num;

 }

 else{

 current_packet_num=(++pre_packet_num);

 pre_packet_num =current_packet_num;

 }

 if (train_dir == NULL || file_name == NULL || data == NULL)

 return -1;

 memset(file_path, '', sizeof(file_path));

 strcpy(file_path, train_dir);

 strcat(file_path, file_name);

 /*if (packet_num == 1) {

 if((file_p = fopen(file_path, "w+")) == NULL) {

 perror("fopen file error");

 return -1;

 }

 } else */

 //{

 if((file_p = fopen(file_path, "a+")) == NULL) {

 perror("fopen file error");

 return -1;

 }

// }

 packet_num= current_packet_num;

 //fprintf(file_p,"current_packet_num:",current_packet_num);

 fprintf(file_p, "------------------ pakcet %d ------------------- ", packet_num);

 fprintf(file_p, "%s ", get_data_time());

 if (write_head(file_p, h_data) < 0) {

 fclose(file_p);

 return -2;

 }

 if (write_message_id(file_p, message_id) < 0) {

 fclose(file_p);

 return -3;

 }

 if (write_body(file_p, data, len, message_id) < 0) {

 fclose(file_p);

 return -4;

 }

 fprintf(file_p, " ");

 fclose(file_p);



 return 1;

}

/**

* @}

*/

void decode_apdu_handler(int socket_fd, unsigned char *apdu, int apdu_len, struct sockaddr_in dout)

{

 unsigned char type;

 head_s recv_head;

 unsigned char train_num[TRAIN_NUM_LEN];

 unsigned short message_id;

 unsigned char data[PACKET_MAX_LEN];

 unsigned char data1[PACKET_MAX_LEN];



 unsigned char encrypted_data[PACKET_MAX_LEN];

 unsigned char decrypted_data[PACKET_MAX_LEN];



 unsigned char handle_data[PACKET_MAX_LEN];

 int decode_len, temp, data_len,decode_len1;

 int recv_crc = 0;

 char *p;

 int i= 0;

 //-----------------------------//////////////////////////////////////////////////////////////

 unsigned char str[1024];

 unsigned char dst[1024];

 int data_fd;

 int data_fd1;

 int data_fd2;

 int res;

 int bytes_write=0;

 int bytes_read = 0;



 //------------------------------//////////////////////////////////////////////////////////////

 static unsigned char trans_mode;

 //------------------------------/////////////////////////////////////////////////////////////

 if (apdu && (socket_fd != -1) && apdu_len >= PACKET_MIN_LEN) {

 type = (unsigned char)decode_head(&recv_head, apdu, apdu_len);

 //if(apdu_len<35)

 decode_len= HEAD_LEN;

// else

// decode_len= HEAD_LEN+ID_CARD;

//-------------------------------------///////////////////////////////////////////////////////////////////////////////////////

memcpy(data1, apdu, apdu_len);

data_fd1 = open("apdu_data.txt",O_WRONLY|O_APPEND|O_CREAT,0644);



 for(i=0;i<data_len;i++)

 {

 str[2*i] = data1[i] >>4;

 str[2*i+1] = data1[i] & 0xf;

 }

 for(i=0;i<2*data_len;i++)

 {

 sprintf(&dst[i],"%X/n",str[i]);

 printf("%c ",dst[i]);

 }





 res = write(data_fd1, dst, 600);

 bytes_write += res;

 close(data_fd1);

 printf("Process %d finished, %d bytes read ", getpid(), bytes_write);

//---------------------------------------/////////////////////////////////////////////////////////////////////////////////////////

 switch (type)

 {

 case APDU_TYPE_REQUEST:

 temp = decode_train_num(train_num, &apdu[decode_len], apdu_len - decode_len);

 if (temp > 0)

 //printf("temp");

 decode_len+= temp;

 //decode_len=decode_len1+ID_CARD;

 //printf("temp:%s ",temp);

 else {

 printf("decode train num error! ");

 return;

 }

 if(apdu_len>35)

 decode_len= HEAD_LEN+13;

 //decode_len= HEAD_LEN;



 temp = decode_message_id(&message_id, &apdu[decode_len], apdu_len - decode_len);

 if (temp > 0)

 decode_len += temp;



 else {

 printf("decode message id error! ");

 return;

 }





 if (check_message_id(message_id) < 0) {

 printf("decode message id out of range! ");

 return;

 }

 if (check_crc(apdu, &apdu[decode_len], apdu_len - decode_len) < 0) {

 printf("crc error! ");

 return;

 }

 recv_crc = (apdu[apdu_len-2] <<8 ) | apdu[apdu_len-1];

 if(calc_crc(apdu,apdu_len-2) != recv_crc)

 {

 printf("crc error!%d ");

 //return;

 }

//----------------------------------------------------------------------------//--------------------------------------------------------------------------

 /*

 printf("start ");

 for(i=0;i<apdu_len;i++)

 printf("%02x ",apdu[i]);

 printf(" end ");

 */

//----------------------------------------------------------------------//------------------------------------------------------------------------------------

 if(apdu_len<28)

 {





 memcpy(data, apdu, apdu_len);

 trans_mode=(data[21]>>6);

//-------------------------------------------------------------------------------------------------------////////////////////////////////////////////////////////////////////////





 memcpy(data1, apdu, apdu_len);

//--------------------------------------------------------------------------------------------------//////////////////////////////////////////////////////////////////////////////////

 printf(" heart is : ");

 for(i=0;i<apdu_len;i++)

 printf("%02x ",apdu[i]);

 printf(" ");

 }

 else

 {

 //trans_mode =0x10;



 memcpy(encrypted_data,&apdu[17],6);

 memcpy(&encrypted_data[6],&apdu[27],apdu_len-23);

////////////////////////----------------------------------------------------------------------------------------------------------------------------

 memcpy(data,apdu,17);

 memcpy(data,apdu,4);

 memcpy(&data[17],&apdu[23],4);

/////////////////////////-------------------------------------------------------------------------------------------------------/////////////////////////////////////////////////////////////////////////////

 memcpy(data1,apdu,17);

 memcpy(data1,apdu,4);

 memcpy(&data1[17],&apdu[23],4);

///////////////////////------------------------------------------------------------------------------------------------------/////////////////////////////////////////////////////////////////////////////////

 //memcpy(data1,&apdu[23],4);

 //memcpy(data1,&apdu[0],6);

 // mqtt_num++;

 // memcpy(&data1[0],&mqtt_num,4);

 // memcpy(&data1[4],&message_count,4);

 memcpy(&data1[0],&ip_addr,4);

 memcpy(&data1[4],&trans_mode,1);

 memcpy(&data1[5],&port,2);

 memcpy(&data1[7],&apdu[23],4);

 /////////////////////--------------------------------------------------------------//////////////////////////////////////////

 data_fd2 = open("encrypted_data.txt",O_WRONLY|O_APPEND|O_CREAT,0644);



 for(i=0;i<data_len;i++)

 {

 str[2*i] = encrypted_data[i] >>4;

 str[2*i+1] = encrypted_data[i] & 0xf;

 }

 for(i=0;i<2*data_len;i++)

 {

 sprintf(&dst[i],"%X/n",str[i]);

 printf("%c ",dst[i]);

 }





 res = write(data_fd2, dst,600);

 bytes_write += res;

 close(data_fd2);

 printf("Process %d finished, %d bytes read ", getpid(), bytes_write);

//////////////////////////////////--------------------------------------------------------------------------////////////////////////////////////////////



 printf(" 脢媒鸥脻鲁鈧�睹埪Ｂ�%d ",apdu_len-23);

 if(server_decrypt(encrypted_data,decrypted_data,apdu_len-23) == 0)

 {

 for(i=0;i<apdu_len-29;i++)

 printf("%02x ",decrypted_data[i]);

 }



//-//////////////////-------------------------------------------------------------------------------------------------////////////////////
 memcpy(&data[0],&apdu[23],4);

 memcpy(&data[4],decrypted_data,apdu_len-29);
 memcpy(&data1[11],decrypted_data,apdu_len-29);



/////////////////////////////---------------------------------------------------------------------//////////////////////////////
/*

 printf("data------------------------------------------------------------- ");

 for(i=0;i<apdu_len-25;i++)

 printf("%02X",data[i]);

 printf(" end ");

*/
////////////////////////////////////------------------------MQTT-----------------------------------------------------------///////////////////////////////////////////////////////////////////////

 MQTT_topic_data(data,apdu_len - 25);
//////////////////////////////////----------------------------------------------------------------------------------------////////////////////////////////////////////////////////////////////////



 data_fd = open("DataFormFIFO.log",O_WRONLY|O_APPEND|O_CREAT,0644);

 for(i=0;i<data_len;i++)

 {

 str[2*i] = data[i] >>4;

 str[2*i+1] = data[i] & 0xf;

 }

 for(i=0;i<2*data_len;i++)

 {

 sprintf(&dst[i],"%X/n",str[i]);

 printf("%c ",dst[i]);

 }



 res = write(data_fd, dst,600);

 bytes_write += res;

 close(data_fd);





 printf("Process %d finished, %d bytes read ", getpid(), bytes_write);



//------------------------------------------------------------------------------////////////////////////////////////////////

 /*

 printf("kaishi: ");

 for(i=0;i<apdu_len-29;i++)

 printf("%02x ",data[i]);

 printf(" ");
 */

 }


 //memcpy(data, &apdu[decode_len1], apdu_len - decode_len1);

 data_len = apdu_len - decode_len;

//---------------------------------------------------------------------------------------------------/////////////////////////////////////////////////////

 recv_handler(recv_head, message_id, data, data_len,socket_fd, dout);

 set_packet_total(dout);



 if ((p = create_train_dir(train_num)) == NULL)

 printf("create dir error! ");

 if (write_message_to_file(p, file_name, recv_head, message_id, data, data_len, get_packet_total(dout)) < 0)

 printf("write file error! ");

//-------------------------------------------------------------------------------------------------/////////////////////////////////////////////////////

 break;

 case APDU_TYPE_ACK:

 printf("recv ack data!!!!!! ");

 break;

 default:

 printf("decode type-(%d) error! ", type);

 break;



 }

 } else

 printf("decode apdu error! ");

}

void udp_thread(void)

{

 unsigned char data[PACKET_MAX_LEN];

 int data_len = 0;

 int socket_fd = -1;

 //char test_flag = 0;

 struct sockaddr_in dout;

 unsigned short i = 0;
 bool quiet = false;

// unsigned char sent_data[PACKET_MAX_LEN];

 //int j;

#if 0

 unsigned short xxx;

 unsigned char zzz[74] = {

 0x30, 0x6b, 0x00, 0xa8, 0x01, 0x00, 0x6c, 0x23, 0x31, 0x00, 0x30,

 0x30, 0x31, 0x32, 0x33, 0x34, 0x2c, 0x10, 0x00,

 0x00, 0x05, 0x80, 0xd9, 0x00};

 xxx = calc_crc(zzz, 22);

 printf("crc %04x ", xxx);

#endif

 /* Initialize sent_apdu_function pointer */

 //init_handler();



 /* TCP socket server setup */

 tcp_set_port(htons(0x1A85));//6789

 printf("set udp port is 6789! ");

 //operator_login();

 if (tcp_init())

 printf("udp server socket opened! ");

 int_packet();

//------------------------------------------------//////////////////////////////////////////////////////////////////////

 int k=0;
 char *username="thit";
 char *password="qwe!@#";


 char *host = "192.168.9.12";

 int port = 1883;

 int keepalive = 60;

 bool clean_session = true;

 mosquitto_lib_init();

 mosq = mosquitto_new("track01", clean_session, NULL);

 if(!mosq){

 fprintf(stderr, "Error: Out of memory. ");

 /*return 0;*/

 }

 mosquitto_log_callback_set(mosq, my_log_callback);

 //*mosquitto_connect_callback_set(mosq, my_connect_callback);

 mosquitto_message_callback_set(mosq, my_message_callback);

 mosquitto_subscribe_callback_set(mosq, my_subscribe_callback);
//---------------------------------------------------------------------------------------------------------------
 //----return :------------------
 // x= mosquitto_username_pw_set(mosq, username, password);
 //printf("----------------------------------------------data= %d ",x);
 //printf("username= %s ",username);
//---------------------------------------------------------------------------------------------------------------
 if(username && mosquitto_username_pw_set(mosq, username, password)){
 printf("---------------------------------UUUUUUU-------------------------------------------------------------username= %s ",(*mosq).username);
 }
 else
 { //设置用户名，密码
 if(!quiet){
 fprintf(stderr, "Error: Problem setting username and password. ");
 }

 // return 1;
 }



 if(mosquitto_connect(mosq,host, port, keepalive))

 {

 fprintf(", %d", k);

 /* return 1;*/

 }
 //}

//-----------------------------------------------////////////////////////////////////////////////////////////////////////

 while (1) {

 /*

 if (heart_num <255)

 { heart_num++;

 }

 else

 {

 heart_num=0;

 }

 */

 /* Initialize test board */

 //init_test_handler();

 /* TCP process */

 socket_fd = tcp_get_socket();

#if 0

 decode_apdu_handler(socket_fd, zzz, 74, dout);

 return;

#endif

#if 0

 data_len = 32;

 printf("------------------start--------------------- ");

 if (decrypt(data, handle_data, data_len) == 0) {

 printf("decrypt len = %d ", data_len);

 printf("unsigned char decrypt_data = { ");

 for (j = 0; j < data_len; j++) {

 if (j != data_len - 1)

 printf("0x%02x, ", handle_data[j]);

 else

 printf("0x%02x}; ", handle_data[j]);

 }

 } else

 printf("decrypt error!!! ");

 for (j = 0; j < 13; j++) {

 sent_data[j] = j;

 }

 apdu_sent(socket_fd, sent_data, 13, dout);

 printf("-------------------------------------------- ");

 return;

#endif

 // printf ("s2 ");

 data_len = tcp_receive(socket_fd, data, PACKET_MAX_LEN, 10, &dout);



 if (data_len > 0) {

 printf("RX: ");

 for (i = 0; i < data_len; i++) //test

 printf("%02x ", data[i]);

 printf(" ");

 decode_apdu_handler(socket_fd, data, data_len, dout);

 //apdu_sent(socket_fd, handle_data, data_len, dout);

 data_len = 0;

 }

 }
////////////////////////////////////////////////////-------------------------------MQTT---------------------------------------///////////////////////////////////////////////////////////////////

 mosquitto_loop_forever(mosq, -1, 1);

 mosquitto_destroy(mosq);

 mosquitto_lib_cleanup();
////////////////////////////////////////////////////-----------------------------------------------------------------------////////////////////////////////////////////////////////////////////////

 return;

}

/*

void java_udp_init(void)

{

 pthread_t thread_id;

 pthread_create(&thread_id, NULL, (void *)udp_thread, NULL);

}

*/

/**

* @}

*/

/******************* (C) COPYRIGHT 2012 THIT *****END OF FILE****/

原文地址：https://www.cnblogs.com/dpf-learn/p/6963561.html