gateway.c 13.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h> //inet_addr
#include <unistd.h>
#include <stdint.h>
#include <pthread.h>
#include <sys/time.h>
#include <libpq-fe.h>
#include <math.h>
#include <signal.h>
#include <time.h>

#include <errno.h>

#include "gateway_protocol.h"
#include "base64.h"
#include "task_queue.h"

21
#define NTHREAD_MAX			10
Vladislav Rykov's avatar
Vladislav Rykov committed
22

Vladislav Rykov's avatar
Vladislav Rykov committed
23
24
25
#define TIMEDATE_LENGTH			32
#define PEND_SEND_RETRIES_MAX		5
#define GATEWAY_PROTOCOL_APP_KEY_SIZE	8
Vladislav Rykov's avatar
Vladislav Rykov committed
26
#define DEVICE_DATA_MAX_LENGTH		256
Vladislav Rykov's avatar
Vladislav Rykov committed
27

Vladislav Rykov's avatar
Vladislav Rykov committed
28
29
typedef struct {
	uint32_t utc;
Vladislav Rykov's avatar
Vladislav Rykov committed
30
	char timedate[TIMEDATE_LENGTH];
Vladislav Rykov's avatar
Vladislav Rykov committed
31

Vladislav Rykov's avatar
Vladislav Rykov committed
32
33
	uint8_t data[DEVICE_DATA_MAX_LENGTH];
	uint8_t data_length;
Vladislav Rykov's avatar
Vladislav Rykov committed
34
35
} sensor_data_t;

Vladislav Rykov's avatar
Vladislav Rykov committed
36
typedef struct {
Vladislav Rykov's avatar
Vladislav Rykov committed
37
	uint8_t app_key[GATEWAY_PROTOCOL_APP_KEY_SIZE +1];
Vladislav Rykov's avatar
Vladislav Rykov committed
38
39
40
41
42
43
44
45
	uint8_t dev_id;
	int server_desc;
	int client_desc;
	struct sockaddr_in server;
	struct sockaddr_in client;
	int sock_len;
} gcom_ch_t; // gateway communication channel

46
47
48
49
50
51
52
typedef struct {
	gcom_ch_t gch;	
	gateway_protocol_packet_type_t packet_type;
	uint8_t packet[DEVICE_DATA_MAX_LENGTH];
	uint8_t packet_length;
} gcom_ch_request_t;

Vladislav Rykov's avatar
Vladislav Rykov committed
53
54
/* for multithreading impl */
void * connection_handler (void *args);
55
void process_packet(void *request);
Vladislav Rykov's avatar
Vladislav Rykov committed
56

Vladislav Rykov's avatar
Vladislav Rykov committed
57
58
59
int send_gcom_ch(gcom_ch_t *gch, uint8_t *pck, uint8_t pck_size);
int recv_gcom_ch(gcom_ch_t *gch, uint8_t *pck, uint8_t *pck_length, uint16_t pck_size);

Vladislav Rykov's avatar
Vladislav Rykov committed
60
void packet_encode(
Vladislav Rykov's avatar
Vladislav Rykov committed
61
62
63
64
65
	const uint8_t *app_key,
	const uint8_t dev_id, 
	const gateway_protocol_packet_type_t p_type, 
	const uint8_t payload_length,
	const uint8_t *payload,
Vladislav Rykov's avatar
Vladislav Rykov committed
66
67
68
	uint8_t *packet_length,
	uint8_t *packet);
uint8_t packet_decode(
Vladislav Rykov's avatar
Vladislav Rykov committed
69
	uint8_t *app_key,
Vladislav Rykov's avatar
Vladislav Rykov committed
70
71
72
73
	uint8_t *dev_id,
	gateway_protocol_packet_type_t *ptype,
	uint8_t *payload_length,
	uint8_t *payload,
Vladislav Rykov's avatar
Vladislav Rykov committed
74
75
	const uint8_t packet_length,
	const uint8_t *packet);
Vladislav Rykov's avatar
Vladislav Rykov committed
76
77
78
79
void gateway_protocol_data_send_payload_decode(
	sensor_data_t *sensor_data, 
	const uint8_t *payload, 
	const uint8_t payload_length);
Vladislav Rykov's avatar
Vladislav Rykov committed
80

Vladislav Rykov's avatar
Vladislav Rykov committed
81
82
83
84
85
86
87
88
void gateway_protocol_mk_stat(
	gcom_ch_t *gch,
	gateway_protocol_stat_t stat,
	uint8_t *pck,
	uint8_t *pck_len);

void send_utc(gcom_ch_t *pch);

Vladislav Rykov's avatar
Vladislav Rykov committed
89
90
void ctrc_handler (int sig);
static volatile uint8_t working = 1;
Vladislav Rykov's avatar
Vladislav Rykov committed
91

92
93
94
pthread_mutex_t mutex;
PGconn *conn;

Vladislav Rykov's avatar
Vladislav Rykov committed
95
int main (int argc, char **argv) {
96
	gcom_ch_t gch;
97
98
	task_queue_t *tq;

Vladislav Rykov's avatar
Vladislav Rykov committed
99
	signal(SIGINT, ctrc_handler);
Vladislav Rykov's avatar
Vladislav Rykov committed
100

101
	conn = PQconnectdb("user=vlad dbname=iotserver password=dev");
Vladislav Rykov's avatar
Vladislav Rykov committed
102
	if (PQstatus(conn) == CONNECTION_BAD) {
Vladislav Rykov's avatar
Vladislav Rykov committed
103
		fprintf(stderr,"connection to db error: %s\n", PQerrorMessage(conn));
Vladislav Rykov's avatar
Vladislav Rykov committed
104
105
106
		return EXIT_FAILURE;
	}

Vladislav Rykov's avatar
Vladislav Rykov committed
107
	if ((gch.server_desc = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
Vladislav Rykov's avatar
Vladislav Rykov committed
108
109
110
111
		perror("socket creation error");
		return EXIT_FAILURE;
	}

Vladislav Rykov's avatar
Vladislav Rykov committed
112
	gch.server.sin_family 		= AF_INET;
113
	gch.server.sin_port		= htons(54445);
Vladislav Rykov's avatar
Vladislav Rykov committed
114
	gch.server.sin_addr.s_addr 	= INADDR_ANY;
Vladislav Rykov's avatar
Vladislav Rykov committed
115

Vladislav Rykov's avatar
Vladislav Rykov committed
116
	if (bind(gch.server_desc, (struct sockaddr *) &gch.server, sizeof(gch.server)) < 0) {
Vladislav Rykov's avatar
Vladislav Rykov committed
117
118
119
120
		perror("binding error");
		return EXIT_FAILURE;
	}

121
122
123
124
	if(!(tq = task_queue_create(NTHREAD_MAX))) {
		perror("task_queue creation error");
		return EXIT_FAILURE;
	}
125
126

	pthread_mutex_init(&mutex, NULL);
Vladislav Rykov's avatar
Vladislav Rykov committed
127
128
	
	while (working) {
129
130
131
		gcom_ch_request_t *req = (gcom_ch_request_t *)malloc(sizeof(gcom_ch_request_t));
		memset(req, 0x0, sizeof(gcom_ch_request_t));
		memcpy(&req->gch, &gch, sizeof(gcom_ch_t));
132
	
Vladislav Rykov's avatar
Vladislav Rykov committed
133
		printf("listenninig...\n");
134
		req->gch.sock_len = sizeof(req->gch.client);
Vladislav Rykov's avatar
Vladislav Rykov committed
135
		
136
137
		if (recv_gcom_ch(&req->gch, req->packet, &req->packet_length, DEVICE_DATA_MAX_LENGTH)) {
			task_queue_enqueue(tq, process_packet, req);
Vladislav Rykov's avatar
Vladislav Rykov committed
138
		} else {
Vladislav Rykov's avatar
Vladislav Rykov committed
139
140
			
			fprintf(stderr, "payload decode error\n");
Vladislav Rykov's avatar
Vladislav Rykov committed
141
		}
Vladislav Rykov's avatar
Vladislav Rykov committed
142
143
	}

144
	pthread_mutex_destroy(&mutex);
Vladislav Rykov's avatar
Vladislav Rykov committed
145
	close(gch.server_desc);
Vladislav Rykov's avatar
Vladislav Rykov committed
146
	PQfinish(conn);
Vladislav Rykov's avatar
Vladislav Rykov committed
147

Vladislav Rykov's avatar
Vladislav Rykov committed
148
149
150
	return EXIT_SUCCESS;
}

Vladislav Rykov's avatar
Vladislav Rykov committed
151
152
153
154
void ctrc_handler (int sig) {
	working = 0;
}

155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
void process_packet(void *request) {
	gcom_ch_request_t *req = (gcom_ch_request_t *)request;
	uint8_t payload[DEVICE_DATA_MAX_LENGTH];
	uint8_t payload_length;	
	PGresult *res;

	if (packet_decode(
		req->gch.app_key,
		&(req->gch.dev_id),
		&(req->packet_type),
		&payload_length, payload,
		req->packet_length, req->packet))
	{
		if (req->packet_type == GATEWAY_PROTOCOL_PACKET_TYPE_TIME_REQ) {
			printf("TIME REQ received\n");
			send_utc(&(req->gch));
		} else if (req->packet_type == GATEWAY_PROTOCOL_PACKET_TYPE_DATA_SEND) {
			sensor_data_t sensor_data;
			time_t t;
			// DEVICE_DATA_MAX_LENGTH*2 {hex} + 150
			char db_query[662];

			printf("DATA SEND received\n");
			gateway_protocol_data_send_payload_decode(&sensor_data, payload, payload_length);
			
			if (sensor_data.utc == 0) {
				struct timeval tv;
				gettimeofday(&tv, NULL);
				t = tv.tv_sec;
			} else {
				t = sensor_data.utc;
			}
			
			strftime(sensor_data.timedate, TIMEDATE_LENGTH, "%d/%m/%Y %H:%M:%S", localtime(&t));
			snprintf(db_query, sizeof(db_query), 
				"INSERT INTO dev_%s_%d VALUES (%d, '%s', $1)", 
				(char *)req->gch.app_key, req->gch.dev_id, t, sensor_data.timedate
			);
			
			const char *params[1];
			int paramslen[1];
			int paramsfor[1];
			params[0] = sensor_data.data;
			paramslen[0] = sensor_data.data_length;
			paramsfor[0] = 1; // format - binary

201
			pthread_mutex_lock(&mutex);
202
			res = PQexecParams(conn, db_query, 1, NULL, params, paramslen, paramsfor, 0);
203
204
			pthread_mutex_unlock(&mutex);

205
206
207
208
209
210
211
			if (PQresultStatus(res) == PGRES_COMMAND_OK) {
				PQclear(res);

				snprintf(db_query, sizeof(db_query),
					 "SELECT * FROM pend_msgs WHERE app_key='%s' and dev_id = %d and ack = False", 
					(char *)req->gch.app_key, req->gch.dev_id
				);
212
213
				
				pthread_mutex_lock(&mutex);
214
				res = PQexec(conn, db_query);
215
216
				pthread_mutex_unlock(&mutex);
				
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
				if (PQresultStatus(res) == PGRES_TUPLES_OK && PQntuples(res)) {
					gateway_protocol_mk_stat(
						&(req->gch), 
						GATEWAY_PROTOCOL_STAT_ACK_PEND,
						req->packet, &(req->packet_length));
					printf("ACK_PEND prepared\n");
				} else {
					gateway_protocol_mk_stat(
						&(req->gch), 
						GATEWAY_PROTOCOL_STAT_ACK,
						req->packet, &(req->packet_length));
					printf("ACK prepared\n");
				}
				
				send_gcom_ch(&(req->gch), req->packet, req->packet_length);
			} else {
				fprintf(stderr, "database error : %s\n", PQerrorMessage(conn));
			}
			PQclear(res);
		} else if (req->packet_type == GATEWAY_PROTOCOL_PACKET_TYPE_PEND_REQ) {
			char db_query[200];
			snprintf(db_query, sizeof(db_query),
				 "SELECT * FROM pend_msgs WHERE app_key = '%s' AND dev_id = %d AND ack = False", 
				(char *)req->gch.app_key, req->gch.dev_id
			);
242
			pthread_mutex_lock(&mutex);
243
			res = PQexec(conn, db_query);
244
			pthread_mutex_unlock(&mutex);
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
			
			if (PQresultStatus(res) == PGRES_TUPLES_OK && PQntuples(res)) {
				char msg_cont[150];
				strncpy(msg_cont, PQgetvalue(res, 0, 2), sizeof(msg_cont));
				printf("PEND_SEND prepared : %s\n", msg_cont);
				PQclear(res);
			
				base64_decode(msg_cont, strlen(msg_cont)-1, payload);
				payload_length = BASE64_DECODE_OUT_SIZE(strlen(msg_cont));
				printf("prepared to send %d bytes : %s\n", payload_length, payload);
				
				// send the msg until ack is received
				uint8_t received_ack = 0;
				uint8_t pend_send_retries = PEND_SEND_RETRIES_MAX;
				struct timeval tv;
				tv.tv_sec = 0;
				tv.tv_usec = 300000; // 300ms ack recv timeout
				do {
					packet_encode(
						req->gch.app_key,
						req->gch.dev_id, 
						GATEWAY_PROTOCOL_PACKET_TYPE_PEND_SEND,
						payload_length, payload,
						&(req->packet_length), req->packet);

					send_gcom_ch(&(req->gch), req->packet, req->packet_length);
					// set timeout
					if (setsockopt(req->gch.server_desc, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
						perror("setsockopt error");
					}
					if (recv_gcom_ch(&(req->gch), 
						req->packet, 
						&(req->packet_length),
						DEVICE_DATA_MAX_LENGTH) > 9)
					{ /* min packet size. timeout -> -1 */
						uint8_t recv_app_key[GATEWAY_PROTOCOL_APP_KEY_SIZE +1];
						uint8_t recv_dev_id = 0xFF;
						if (packet_decode(
							recv_app_key,
							&recv_dev_id, 
							&(req->packet_type),
							&(req->packet_length), req->packet,
							req->packet_length, req->packet)) 
						{
289
290
291
							if (!memcmp(recv_app_key, req->gch.app_key, GATEWAY_PROTOCOL_APP_KEY_SIZE) &&
								recv_dev_id == req->gch.dev_id &&
								req->packet_type == GATEWAY_PROTOCOL_PACKET_TYPE_STAT &&
292
293
								req->packet_length == 1 &&
								req->packet[0] == GATEWAY_PROTOCOL_STAT_ACK)
294
295
296
							{
								snprintf(db_query, sizeof(db_query),
								 	"UPDATE pend_msgs SET ack = True WHERE app_key = '%s' AND dev_id = %d AND msg = '%s'", 
297
									(char *)req->gch.app_key, req->gch.dev_id, msg_cont
298
								);
299
300
301
								pthread_mutex_lock(&mutex);
								res = PQexec(conn, db_query);
								pthread_mutex_unlock(&mutex);
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
								if (PQresultStatus(res) != PGRES_COMMAND_OK) {
									fprintf(stderr, "error db deleting : %s", PQerrorMessage(conn));
								}
								PQclear(res);
								received_ack = 1;
								printf("ACK received\n");
							} else {
								printf("error: packet_type = %02X, not STAT\n");
							}
						}
					}
				} while (!received_ack && pend_send_retries--);
				// cancel timeout
				tv.tv_usec = 0;	
				if (setsockopt(req->gch.server_desc, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) {
					perror("setsockopt error");
				}
			} else {
				gateway_protocol_mk_stat(
					&(req->gch),
					GATEWAY_PROTOCOL_STAT_NACK,
					req->packet, &(req->packet_length));
				
				send_gcom_ch(&(req->gch), req->packet, req->packet_length);
				
				printf("nothing for app %s dev %d\n", (char *)req->gch.app_key, req->gch.dev_id);
			}
		} else {
			gateway_protocol_mk_stat(
				&(req->gch),
				GATEWAY_PROTOCOL_STAT_NACK,
				req->packet, &(req->packet_length));
			
			send_gcom_ch(&(req->gch), req->packet, req->packet_length);
				
337
			fprintf(stderr, "packet type error : %02X\n", req->packet_type);
338
339
340
341
		}
	} else {
		fprintf(stderr, "payload decode error\n");
	}
342
343
	
	free(req);
344
345
}

Vladislav Rykov's avatar
Vladislav Rykov committed
346
void gateway_protocol_data_send_payload_decode(
Vladislav Rykov's avatar
Vladislav Rykov committed
347
348
349
350
	sensor_data_t *sensor_data, 
	const uint8_t *payload, 
	const uint8_t payload_length) 
{
Vladislav Rykov's avatar
Vladislav Rykov committed
351
352
353
354
355
	uint8_t p_len = 0;

	memcpy(&sensor_data->utc, &payload[p_len], sizeof(sensor_data->utc));
	p_len += sizeof(sensor_data->utc);

Vladislav Rykov's avatar
Vladislav Rykov committed
356
357
	memcpy(sensor_data->data, &payload[p_len], payload_length - p_len);
	sensor_data->data_length = payload_length - p_len;
Vladislav Rykov's avatar
Vladislav Rykov committed
358
359
}

Vladislav Rykov's avatar
Vladislav Rykov committed
360
void packet_encode(
Vladislav Rykov's avatar
Vladislav Rykov committed
361
362
363
364
365
	const uint8_t *app_key,
	const uint8_t dev_id, 
	const gateway_protocol_packet_type_t p_type, 
	const uint8_t payload_length,
	const uint8_t *payload,
Vladislav Rykov's avatar
Vladislav Rykov committed
366
367
368
369
	uint8_t *packet_length,
	uint8_t *packet) 
{
	*packet_length = 0;
Vladislav Rykov's avatar
Vladislav Rykov committed
370
371
372
	
	memcpy(&packet[*packet_length], app_key, GATEWAY_PROTOCOL_APP_KEY_SIZE);
	*packet_length += GATEWAY_PROTOCOL_APP_KEY_SIZE;
Vladislav Rykov's avatar
Vladislav Rykov committed
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387

	packet[*packet_length] = dev_id;
	(*packet_length)++;

	packet[*packet_length] = p_type;
	(*packet_length)++;

	packet[*packet_length] = payload_length;
	(*packet_length)++;

	memcpy(&packet[*packet_length], payload, payload_length);
	*packet_length += payload_length;
}

uint8_t packet_decode(
Vladislav Rykov's avatar
Vladislav Rykov committed
388
	uint8_t *app_key,
Vladislav Rykov's avatar
Vladislav Rykov committed
389
390
391
392
	uint8_t *dev_id,
	gateway_protocol_packet_type_t *ptype,
	uint8_t *payload_length,
	uint8_t *payload,
Vladislav Rykov's avatar
Vladislav Rykov committed
393
394
	const uint8_t packet_length,
	const uint8_t *packet)
Vladislav Rykov's avatar
Vladislav Rykov committed
395
396
{
	uint8_t p_len = 0;
Vladislav Rykov's avatar
Vladislav Rykov committed
397
398
399
	
	memcpy(app_key, &packet[p_len], GATEWAY_PROTOCOL_APP_KEY_SIZE);
	p_len += GATEWAY_PROTOCOL_APP_KEY_SIZE;
Vladislav Rykov's avatar
Vladislav Rykov committed
400
401
	
	app_key[GATEWAY_PROTOCOL_APP_KEY_SIZE] = '\0';
Vladislav Rykov's avatar
Vladislav Rykov committed
402
403
404
405
406
407
408
409
410
411
412
413
414

	*dev_id = packet[p_len];
	p_len++;

	*ptype = (gateway_protocol_packet_type_t) packet[p_len];
	p_len++;

	*payload_length = packet[p_len];
	p_len++;

	memcpy(payload, &packet[p_len], *payload_length);
	p_len += *payload_length;

Vladislav Rykov's avatar
Vladislav Rykov committed
415
416
	printf("payload_length = %d , calc = %d, recv = %d\n", *payload_length, p_len, packet_length);

Vladislav Rykov's avatar
Vladislav Rykov committed
417
418
419
	return p_len == packet_length;
}

Vladislav Rykov's avatar
Vladislav Rykov committed
420
421
422
423
424
425
void gateway_protocol_mk_stat(
	gcom_ch_t *gch,
	gateway_protocol_stat_t stat,
	uint8_t *pck,
	uint8_t *pck_len)
{
Vladislav Rykov's avatar
Vladislav Rykov committed
426
427
428
429
	packet_encode(
		gch->app_key,
		gch->dev_id,
		GATEWAY_PROTOCOL_PACKET_TYPE_STAT,
Vladislav Rykov's avatar
Vladislav Rykov committed
430
		1, (uint8_t *)&stat,
Vladislav Rykov's avatar
Vladislav Rykov committed
431
		pck_len, pck);
Vladislav Rykov's avatar
Vladislav Rykov committed
432
433
}

Vladislav Rykov's avatar
Vladislav Rykov committed
434
435


Vladislav Rykov's avatar
Vladislav Rykov committed
436
void send_utc(gcom_ch_t *gch) {
Vladislav Rykov's avatar
Vladislav Rykov committed
437
	uint8_t buf[50];
Vladislav Rykov's avatar
Vladislav Rykov committed
438
439
440
441
442
443
	uint8_t buf_len = 0;
	struct timeval tv;
				
	gettimeofday(&tv, NULL);
				
	packet_encode (
Vladislav Rykov's avatar
Vladislav Rykov committed
444
		gch->app_key,
Vladislav Rykov's avatar
Vladislav Rykov committed
445
446
		gch->dev_id,
		GATEWAY_PROTOCOL_PACKET_TYPE_TIME_SEND,
Vladislav Rykov's avatar
Vladislav Rykov committed
447
		sizeof(uint32_t), (uint8_t *)&tv.tv_sec,
Vladislav Rykov's avatar
Vladislav Rykov committed
448
449
450
451
452
453
454
		&buf_len, buf
	);
					
	send_gcom_ch(gch, buf, buf_len);
}

int send_gcom_ch(gcom_ch_t *gch, uint8_t *pck, uint8_t pck_size) {
455
	int ret;
Vladislav Rykov's avatar
Vladislav Rykov committed
456
	
457
	if ((ret = sendto(gch->server_desc, (char *)pck, pck_size, 0, (struct sockaddr *)&gch->client, gch->sock_len)) < 0) {
Vladislav Rykov's avatar
Vladislav Rykov committed
458
459
		perror("sendto error");
	}
460

Vladislav Rykov's avatar
Vladislav Rykov committed
461
462
463
464
	return ret;
}

int recv_gcom_ch(gcom_ch_t *gch, uint8_t *pck, uint8_t *pck_length, uint16_t pck_size) {
465
466
	int ret;
	if ((ret = recvfrom(gch->server_desc, (char *)pck, pck_size, MSG_WAITALL, (struct sockaddr *)&gch->client, &gch->sock_len)) < 0) {
Vladislav Rykov's avatar
Vladislav Rykov committed
467
		perror("socket receive error");
468
469
	} else {
		*pck_length = ret;
Vladislav Rykov's avatar
Vladislav Rykov committed
470
	}
471
	
472
	return ret;
Vladislav Rykov's avatar
Vladislav Rykov committed
473
}
Vladislav Rykov's avatar
Vladislav Rykov committed
474
475
/* connection handler for multithreading version */
#ifdef MULTITHREADING_VER
Vladislav Rykov's avatar
Vladislav Rykov committed
476
477
478
479
480
481
482
483
484
485
486
487
void *connection_handler(void *args) {
	int client_desc = *(int *)args;
	
	uint8_t buf[128] = "";
	uint8_t buf_len = 0;
	uint8_t payload[128];
	uint8_t payload_length = 0;

	if ((buf_len = recv(client_desc, buf, sizeof(buf), 0)) > 0) {
		uint8_t dev_id = 0xFF;
		gateway_protocol_packet_type_t packet_type;
		
Vladislav Rykov's avatar
Vladislav Rykov committed
488
		if (gateway_protocol_packet_decode(	
Vladislav Rykov's avatar
Vladislav Rykov committed
489
490
491
492
493
494
					&dev_id,
					&packet_type,
					&payload_length, payload,
					buf_len, buf))
		{
			if (packet_type == GATEWAY_PROTOCOL_PACKET_TYPE_TIME_REQ) {
Vladislav Rykov's avatar
Vladislav Rykov committed
495
				printf("TIME REQ received\n");
Vladislav Rykov's avatar
Vladislav Rykov committed
496
497
498
499
500
501
502
503
504
505
506
507
508
509
				struct timeval tv;
				buf_len = 0;
				
				buf[0] = dev_id;
				buf_len++;

				buf[1] = GATEWAY_PROTOCOL_PACKET_TYPE_TIME_SEND;
				buf_len++;

				gettimeofday(&tv, NULL);
				memcpy(&buf[buf_len], &tv.tv_sec, sizeof(uint32_t));
				buf_len += sizeof(uint32_t);

				write(client_desc, buf, buf_len);
Vladislav Rykov's avatar
Vladislav Rykov committed
510
511
			} else {
				perror("packet type error");
Vladislav Rykov's avatar
Vladislav Rykov committed
512
			}
Vladislav Rykov's avatar
Vladislav Rykov committed
513
514
		} else {
			perror("packet decode error");
Vladislav Rykov's avatar
Vladislav Rykov committed
515
516
517
518
		}
	}

}
Vladislav Rykov's avatar
Vladislav Rykov committed
519
#endif