#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <bits/signum.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SRV_PORT	6666
#define BUFF_SIZE	2048

struct cmd_header {
	unsigned int len;
	unsigned int cmd;
	unsigned int cmd_type;
	unsigned int crc32;
};

#define CMD_HEADER_SIZE		16

#define CMD_DEV_ONLINE		1
//public   static   final   int   CMD_DEV_ONLINE   =   1; 

#define RESP_DEV_ONLINE_SIZE	(16+20+4+4)

#define CMD_SINGLE_VAR_ONLINE	10

static void sig_alarm(int);

int
main(int argc, char *argv[] )
{
	int fd;
	struct sockaddr_in srv_addr, cli_addr;
	socklen_t len;
	char buff[BUFF_SIZE];
	int resp_len;
	int rc = 0;
	struct sigaction sig_act;
	struct cmd_header *cmd_hdr;  //命令头
	char *cmd_body;   //命令体

	sigemptyset(&sig_act.sa_mask);
	sig_act.sa_handler = sig_alarm;
	sig_act.sa_flags = 0;
	sigaction(SIGALRM, &sig_act, NULL);

	fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		printf("cannot create socket!\n");
		return (1);
	}

	memset(&srv_addr, 0, sizeof(srv_addr) );
	srv_addr.sin_family = AF_INET;
	srv_addr.sin_port = htons(SRV_PORT);
	inet_pton(AF_INET, "127.0.0.1", &srv_addr.sin_addr);

	rc = connect(fd, (struct sockaddr *) &srv_addr, sizeof(srv_addr) );
	if (rc < 0) {
		printf("cannot connect to server\n");
		return (1);
	}

	cmd_hdr = (struct cmd_header *) buff;
	cmd_hdr->len = CMD_HEADER_SIZE + 20;
	cmd_hdr->cmd_type = 0;
	cmd_hdr->cmd = CMD_DEV_ONLINE;
	cmd_hdr->crc32 = 0x44444444;

	cmd_body = buff + CMD_HEADER_SIZE;
	memcpy(cmd_body, "dev_uid: 0x12345678", 20);

	send(fd, buff, cmd_hdr->len, 0);

	/* set up an alarm to receive the query result */
	alarm(5);	/* 5 seconds */

	memset(buff, 0, BUFF_SIZE);
	resp_len = recv(fd, buff, BUFF_SIZE, 0);
	if (resp_len < 0) {
		if (errno == EINTR)
			printf("timeout\n");
		else
			printf("error receiving data\n");
	} else {
		/* do some sanity checks */
		if (resp_len != cmd_hdr->len)
			printf("correpted data received\n");
		else {
			int status, offline_reason;

			status = *(unsigned int *) (cmd_body+20);
			status = *(unsigned int *) (cmd_body+20+4);

			printf("cmd_type: %d\n", cmd_hdr->cmd_type);
			printf("cmd:      %d\n", cmd_hdr->cmd);
			printf("crc32:    0x%8x\n", cmd_hdr->crc32);
			printf("dev_uid:  %s\n", cmd_body);
			printf("dev_status: %d\n", status);
			printf("offline reason: %d\n", offline_reason);
		}
	}

	close(fd);

	return (0);
}

static void sig_alarm(int signo)
{
	return;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <bits/signum.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SRV_PORT	6666
#define BUFF_SIZE	2048

struct cmd_header {
	unsigned int len;
	unsigned int cmd;
	unsigned int cmd_type;
	unsigned int crc32;
};

#define CMD_HEADER_SIZE		16

#define CMD_DEV_ONLINE		1
#define RESP_DEV_ONLINE_SIZE	(16+20+4+4)

#define CMD_SINGLE_VAR_ONLINE	10

static void sig_alarm(int);

int
main(int argc, char *argv[] )
{
	int srv_fd, cli_fd;
	struct sockaddr_in srv_addr, cli_addr;
	socklen_t len;
	pid_t pid;
	char buff[BUFF_SIZE];
	int req_len;
	int rc = 0;

	srv_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (srv_fd < 0) {
		printf("cannot create socket!\n");
		return (1);
	}

	memset(&srv_addr, 0, sizeof(srv_addr) );
	srv_addr.sin_family = AF_INET;
	srv_addr.sin_port = htons(SRV_PORT);
	srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	rc = bind(srv_fd, (struct sockaddr *) &srv_addr, sizeof(srv_addr) );
	if (rc < 0) {
		printf("cannot bind on port %d\n", SRV_PORT);
		return (1);
	}

	rc = listen(srv_fd, 5);
	if (rc < 0) {
		printf("cannot listen on port %d\n", SRV_PORT);
		return (1);
	}

	len = sizeof(cli_addr);


	while (1) {
		cli_fd = accept(srv_fd, (struct sockaddr *) &cli_addr, &len);
		if (cli_fd < 0) {
			printf("error when accepting connection\n");
			continue;
		}

		if ( (pid = fork() == 0) ) {
			struct cmd_header *cmd_hdr;
			char *cmd_body;
			struct sigaction sig_act;
			char response[BUFF_SIZE];

			sigemptyset(&sig_act.sa_mask);
			sig_act.sa_handler = sig_alarm;
			sig_act.sa_flags = 0;
			sigaction(SIGALRM, &sig_act, NULL);

			while (1) {
				alarm(30);

				req_len = recv(cli_fd, buff, BUFF_SIZE, 0);
				if (req_len < 0) {
					if (errno == EINTR)
						printf("socket timeout\n");
					else
						printf("error when receiving data\n");

					alarm(0);
					close(cli_fd);
					exit(1);
				} else {
					if (req_len == 0)
						continue;

					alarm(0);

					/* process the incoming request */
					cmd_hdr = (struct cmd_header *) buff;
					cmd_body = buff + sizeof(struct cmd_header);

					switch (cmd_hdr->cmd_type) {
					case (0):
						switch (cmd_hdr->cmd) {
						case (CMD_DEV_ONLINE): {
							char *dev_uid = cmd_body;
							unsigned int *status, *offline_reason;

							printf("crc32: 0x%08x\n", cmd_hdr->crc32);
							dev_uid[20] = '\0';
							printf("dev_uid: %s\n", dev_uid);

							/* now do some stuff to get the result ... */
							// do_something();

							/* setup the response message:
							 * 1) set up the header, compute CRC;
							 * 2) fill up the message body.
							 * 	In this example, they're DEV_UID and,
							 * 	STATUS and OFFLIE_REASON.
							 */
							memcpy(response, cmd_hdr, 16);
							memcpy(response+16, cmd_body, 20);

							cmd_hdr = (struct cmd_header *) response;
							cmd_hdr->len = CMD_HEADER_SIZE+20+4+4;
							cmd_hdr->crc32 = 0x5a5a5a5a;

							cmd_body = response + CMD_HEADER_SIZE;

							status = (unsigned int *) (cmd_body+20);
							offline_reason = status+1;

							*status = 1;
							*offline_reason = 0;

							send(cli_fd, response, RESP_DEV_ONLINE_SIZE, 0);

						        }
							break;

						case (CMD_SINGLE_VAR_ONLINE):

							break;

						default:
							printf("unknow command\n");
							break;
						}

						break;

					case (1):
						break;

					default:
						break;
					}
				}

			}

			close(cli_fd);

			exit(0);
		}
	}

	close(srv_fd);

	return (0);
}

static void sig_alarm(int signo)
{
	return;
}