【linxu c】driver+socket

makefile: 前同，改下文件名

驱动：driver.c

#include<linux/init.h>
#include<linux/kernel.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/miscdevice.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/slab.h>

#define MAX 200

MODULE_LICENSE("Dual BSD/GPL");

static char data[2][2][MAX] = {
	{
		{"123"},
		{"456"},
	},
	{ 
		{"789"},
		{"012"},		
	},
};

static int pointer = -1;

static int misc_open(struct inode *nd,struct file *filp)
{
	printk(KERN_ALERT"misc_open success\n");
	return 0;
}

static ssize_t misc_read(struct file *filp, char __user *buf, size_t count,loff_t *ppos)
{
	printk(KERN_ALERT"In the misc_read() function!\n");
	printk("read ppos =%d\n",(unsigned int)*ppos);
	char temp[MAX] = {0};
	
	if(pointer != -1){
		strcpy(temp,data[pointer][1]);
		if(copy_to_user(buf,temp,count)){
			pointer = -1;
			return -EFAULT;   
		}
		printk("send to client:%s\n",buf);
	}
	pointer = -1;
	
	return 0;
}
static ssize_t misc_write(struct file *filp, const char __user *buf, size_t count,loff_t *ppos)                                                              
{
	printk("in the write..\n");
	printk("write ppos=%d\n",(unsigned int)*ppos);
	char temp[MAX] = {0};
    int i = 0;

	if(copy_from_user(temp,buf,count)){
		pointer = -1;
		return -EFAULT;
	}	
    printk("recv from client:%s\n",temp);
	
	for(i = 0;i < sizeof(data)/sizeof(data[0]);i++){
		if (strcmp(temp, data[i][0]) == 0){
			pointer = i;
			printk("find position:pointer=%d\n",pointer);	
			return 0;
		}
	}       
    return 0;      
}                                                                           

struct file_operations misc_ops =
{
	.owner = THIS_MODULE,
	.open  = misc_open,   
	.read  = misc_read,
	.write = misc_write,
};

struct miscdevice misc=
{
	.minor = MISC_DYNAMIC_MINOR,
	.name = "my_misc_dev",
	.fops = &misc_ops,
};

static int zx_init(void)
{
	int ret = 0;	
	ret = misc_register(&misc);
	printk(KERN_ALERT"\t initialized %s!\n",(0==ret)?"successed":"failed");
    return ret; 
}

static void zx_exit(void)
{
	misc_deregister(&misc);
	printk(KERN_ALERT"Removing misc_dev...!\n");
}

module_init(zx_init);
module_exit(zx_exit);

server.c

/* server
 * File:   server.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include<fcntl.h>
#include<sys/stat.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <sys/unistd.h>

#define MAX 200
#define SERVER_PORT 5555

int main(int argc, char** argv) {

	int key = 0;
	char recv_buf[MAX] = {0};
	char send_buf[MAX] = {"789"}; 
	int server_socket;
	struct sockaddr_in server_addr;
	int iDataNum;
	int server_addr_len;
	
	struct sockaddr_in client_addr;
	int client_addr_len = sizeof(client_addr);
	int client_socket = 0;
	int count = 0;
	
	void initialize_socket () {		
		stpcpy(recv_buf,"");
		
		bzero(&server_addr,sizeof(server_addr));
		server_addr.sin_family = AF_INET;
		server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
		server_addr.sin_port = htons(SERVER_PORT);		
	    server_addr_len = sizeof(server_addr);
		return ;
	}	

	//UDP 
	void udp(){
		printf("You choose the UDP socket!\n");
		printf("Listening on port: %d\n", SERVER_PORT);
			
		if((server_socket = socket(AF_INET,SOCK_DGRAM, 0)) < 0)	{
			perror("socket");
			return ;
		}
		
		//set socket optional to avoid missing use of address
		int on=1;
		if((setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)))<0)
		{
			perror("setsockopt failed");
			exit(EXIT_FAILURE);
		}
		
		initialize_socket();
		bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr));	
		
		while(1){			
			recvfrom(server_socket,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&server_addr,&server_addr_len);
			count ++;
			printf("Recv from client package %d: %s \n",count,recv_buf);
			
			sendto(server_socket, send_buf, sizeof(send_buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));	
			printf("send to client package %d: %s \n",count,send_buf);
			
			stpcpy(recv_buf,"");
			
			sleep(1);
		}
		
		count = 0;
		
		close(server_socket);		
	}
	
	//tcp
	void tcp(){
		printf("You choose the TCP socket!\n");

		if((server_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0)	{
			perror("socket");
			return ;
		}
		
		//set socket optional to avoid missing use of address
		int on=1;
		if((setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)))<0)
		{
			perror("setsockopt failed");
			exit(EXIT_FAILURE);
		}
		
		initialize_socket ();
		if(bind(server_socket, (struct sockaddr *)&server_addr, server_addr_len) < 0)	{
			perror("connect");
			return ;
		}

		if(listen(server_socket, 5) < 0){
			perror("listen");
			return ;
		}
		printf("Listening on port: %d\n", SERVER_PORT);
		client_socket = accept(server_socket, (struct sockaddr*)&client_addr, (socklen_t*)&client_addr_len);	
		if(client_socket < 0){
			perror("accept");
		}
		while(1){				
			send(client_socket, send_buf, sizeof(send_buf), 0);
			count ++;
			printf("sent to client package %d: %s \n",count,send_buf);
			sleep(1);
		}
		
		count = 0;
		
		close(client_socket);
		close(server_socket);
	}
	
	void choose(){
		scanf("%d",&key);		
		while(key != 1 && key != 2) {
			printf("The number is error!\nEnter the number to again:");
			scanf("%d",&key);
		}
		return ;
	}

	//choose the type of package
	printf("-----------choose the type of package-----------\n\t\t 1--the UDP Socket\n\t\t 2--the TCP Socket\nEnter the number to choose:");
	choose();
	switch(key) {
		case 1:	{
			udp();
			break;
		}				
		case 2:	{
			tcp();
			break;
		}
		default:
		   printf("error input!\n");
	       break;
	}
    return 0;
}

client.c

/* client
 * File:   client.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include<unistd.h>
#include<fcntl.h>
#include<signal.h>
#include<sys/stat.h>
#include <sys/unistd.h>

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 5555

#define MAX 200

int main(int argc, char** argv) {
	
	int key;
	int fd;	
	int client_socket;
	struct sockaddr_in server_addr;
	char send_buf[MAX];
	char recv_buf[MAX];
	char result_back[MAX];
	int server_addr_len;
	int iDataNum;
	int count = 0;
	
	void initialize_socket () {	
		client_socket = 0;

		stpcpy(send_buf,"give me data please!");
		stpcpy(recv_buf,"");
		stpcpy(result_back,"");
		
		bzero(&server_addr, sizeof(server_addr));
		server_addr.sin_family = AF_INET;
		server_addr.sin_port = htons(SERVER_PORT);
		server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
		server_addr_len = sizeof(server_addr);		
		return ;
	}
		
	void choose(){
		scanf("%d",&key);		
		while(key != 1 && key != 2) {
			printf("The number is error!\nEnter the number to again:");
			scanf("%d",&key);
		}
		return ;
	}
	
	//connect 5G chip
	void cntWith5Gchip(){	
		fd = open("/dev/my_misc_dev",O_RDWR);
		
		void sendOnly(){
			write(fd,recv_buf,sizeof(recv_buf)-1);
			printf("send to 5G chip: %s\n",recv_buf);
		}
		void sndRecv(){
			sendOnly();
			read(fd,result_back,sizeof(result_back)-1);
			printf("recv from 5G chip:%s\n",result_back);
		}
		
		if(fd != -1){	
			//choose the commounication  mode
			printf("-----------choose the connect mode with 5G chip-----------\n\t\t 1--Only send!\n\t\t 2--Send and receive!\nEnter the number to choose:");
			choose();		
			switch(key){
				case 1:
						sendOnly();						
						break;
				case 2:
						sndRecv();						
						break;
				default:
					break;
			}
		}
		else{
			//printf("5G chip open failure\n");
		}		
		close(fd);
		//printf("5G chip open succeed!\n");
		return ;
	}	

	//choose the type of package
	printf("-----------choose the type of package-----------\n\t\t 1--the UDP Socket\n\t\t 2--the TCP Socket\nEnter the number to choose:");
	choose();

	switch(key) {
		case 1:	{
			//get data from server	
			printf("You choose the UDP socket!\n");			
			initialize_socket ();
			
			if((client_socket = socket(AF_INET,SOCK_DGRAM, 0)) < 0)	{
					printf("client_socket error!\n");
					perror("socket");
					return 1;
			}
			
			while(1){
				sendto(client_socket, send_buf, sizeof(send_buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));	
				count ++;
				printf("----------------------------------------------------------\nSend to server package %d: %s \n",count,send_buf);

				printf("waiting recv data from server...\n");						
				recvfrom(client_socket,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&server_addr,&server_addr_len);			
				printf("receive from server package %d: %s \n",count,recv_buf);			
				
				//connect 5G chip			
				if(recv_buf != ""){
					cntWith5Gchip();
				}else
					printf("server error!\n");
				
				//send the data received from 5gchip to server
				if(strlen(result_back) > 1 ){
					sendto(client_socket, result_back, sizeof(result_back), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));	
					printf("Send to server: %s \n",result_back);
				}
				
				stpcpy(recv_buf,"");
				stpcpy(result_back,"");
				
				sleep(1);
				
			}			
			
			count = 0;
			
			close(client_socket);				
			break;
		}				
		case 2:	{
			//get data from server	
			printf("You choose the TCP socket!\n");			
			initialize_socket ();	
			
			if((client_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0){
				perror("socket");
				return 1;
			}
			if(connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0){
				perror("connect");
				return 1;
			}	
			while(1){
				iDataNum = recv(client_socket, recv_buf, sizeof(recv_buf), 0);
				if(iDataNum < 0){
						perror("recv");
				}
				recv_buf[iDataNum] = '\0';				
				count++;
				printf("------------------------------------------------\n\nrecvfrom server package %d: %s \n",count,recv_buf);
				
				//connect 5G chip			
				if(recv_buf != ""){
					cntWith5Gchip();
				}else
					printf("server error!\n");	
				
				//send the data received from 5gchip to server
				if(strlen(result_back) > 1 ){
					send(client_socket, result_back, sizeof(result_back), 0);
					printf("sent to server: %s \n",result_back);
					
					stpcpy(recv_buf,"");
					stpcpy(result_back,"");
				}
				sleep(1);
			}
			
	        count = 0;
			
			close(client_socket);
			break;
		}
		default :		   
			break;				
	}
    return 0;
}