//命令lsof -i:5999
//简单服务器
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define MYPORT 5999
#define BACKLOG 10
int main(){
int sock_fd, new_fd;
struct sockaddr_in my_addr, their_addr;
int sin_size;
if((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(MYPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
if(bind(sock_fd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) == -1){
perror("bind");
exit(1);
}
if(listen(sock_fd, BACKLOG) == -1){
perror("listen");
exit(1);
}
while(1){
sin_size = sizeof(struct sockaddr_in);
if((new_fd = accept(sock_fd, (struct sockaddr *)&their_addr, &sin_size)) == -1){
perror("accept");
continue;
}
printf("server.got connection from %s\n",inet_ntoa(their_addr.sin_addr));
if(!fork()){
if(send(new_fd, "Hello,world!\n", 14, 0) == -1){
perror("send");
close(new_fd);
exit(0);
}
}
while(waitpid(-1, NULL, WNOHANG) > 0);
}
}
//简单客户端
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 5999
#define MAXDATASIZE 100
int main(int argc, char *argv[]){
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr;
if(argc != 2){
fprintf(stderr, "usage: client hostname\n");
exit(1);
}
if((he = gethostbyname(argv[1])) == NULL){
perror("gethostbyname");
exit(1);
}
// printf();
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT);
//their_addr.sin_addr = *((struct in_addr*)he->h_addr);
their_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
bzero(&(their_addr.sin_zero), 8);
if(connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1){
perror("connect");
exit(1);
}
if((numbytes = recv(sockfd, buf, MAXDATASIZE, 0)) == -1){
perror("recv");
exit(1);
}
buf[numbytes] = '\0';
printf("Received: %s", buf);
close(sockfd);
return 0;
}
//epoll 服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/wait.h>
#define SERVPORT 5999
#define BACKLOG 10 //最大同时连接请求数
void setnonblocking(int sock){
int opts;
opts = fcntl(sock, F_GETFL);
if(opts < 0){
perror("fcntl(sock, GETFL)");
exit(1);
}
opts = opts | O_NONBLOCK;
if(fcntl(sock, F_SETFL, opts) < 0){
perror("fcntl(sock, SETFL, opts)");
exit(1);
}
}
void do_use_fd(int client_fd){
char msg[50];
const char str[] = "God bless you!\n";
recv(client_fd, msg, 50, 0);
printf("get from client msg %s\n", msg);
if(send(client_fd, str, sizeof(str), 0) == -1)
perror("send");
close(client_fd);
}
int main(){
int sockfd;
struct sockaddr_in my_addr;
struct sockaddr_in their_addr;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(SERVPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero), 8);
if(bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1){
perror("bind");
exit(1);
}
if(listen(sockfd, BACKLOG) == -1){
perror("listen");
exit(1);
}
size_t sin_size = sizeof(struct sockaddr_in);
#define MAX_EVENTS 10
struct epoll_event ev, events[MAX_EVENTS];
int conn_sock, nfds, epollfd;
epollfd = epoll_create(10);
if(epollfd == -1){
perror("epoll_create");
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sockfd;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1){
perror("epoll_ctl: sockfd");
exit(EXIT_FAILURE);
}
for(;;){
nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if(nfds == -1){
perror("epoll_wait");
exit(EXIT_FAILURE);
}
int i;
for(i = 0; i < nfds; ++i){
if(events[i].data.fd == sockfd){
conn_sock = accept(sockfd,
(struct sockaddr *)&their_addr, &sin_size);
if(conn_sock == -1){
perror("accept");
exit(EXIT_FAILURE);
}
setnonblocking(conn_sock);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = conn_sock;
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
&ev) == -1){
perror("epoll_ctl: conn_sock");
exit(EXIT_FAILURE);
}
}else{
do_use_fd(events[i].data.fd);
}
}
}
}
//epoll 客户端
#include <stdio.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <string.h>
#define PORT 5999
#define MSG 50
int main(){
int sockfd;
char msg[MSG];
struct sockaddr_in their_addr;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket() failed");
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT);
their_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
bzero(&their_addr.sin_zero, 8);
if(connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1){
perror("connect error");
exit(1);
}
send(sockfd, "HELLO", 20, 0);
recv(sockfd, msg, MSG, 0);
printf("%s\n", msg);
close(sockfd);
}
//管道
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#define MAXMSG 0xff
int main(){
int fd_req[2];/*声明了两个管道描述符，一个用来发询问信息*/
int fd_ans[2];/* 一个用来回答 */
pid_t pid;
char msg[MAXMSG];
if(pipe(fd_req) < 0 || pipe(fd_ans) < 0){
perror("init pipe fault...\n");
return -1;
}
if((pid = fork()) < 0){
perror("init fork fault...\n");
}
if(pid > 0){//father process
close(fd_req[1]);
close(fd_ans[0]);
int res, ask;
printf("Enter a number between 1-1000: ");
scanf("%d", &res); //输入答案
write(fd_ans[1], "start", MAXMSG); //给子进程解锁
while(1){
read(fd_req[0], msg, MAXMSG);
if(strcmp(msg, "end") == 0){ //结束标识，则结束。
close(fd_req[0]);
close(fd_ans[1]);
return 0;
}
ask = atoi(msg);
if(res > ask)
write(fd_ans[1], "yes", MAXMSG);
else
write(fd_ans[1], "no", MAXMSG);
}
}else{
int from = 0, to = 1024, mid;
read(fd_ans[0], msg, MAXMSG); //首先阻塞子进程，直到父进程发消息
while(1){
mid = (from + to) / 2;
sprintf(msg, "%d", mid);
write(fd_req[1], msg, MAXMSG); //询问
printf("Is the number bigger than %d(yes/no)?\n", mid);
read(fd_ans[0], msg, MAXMSG); //回答
printf("%s\n", msg);
if(strcmp(msg, "yes") == 0)
from = mid;
else
to = mid;
if(from + 1 == to){
printf("I have succeeded in guessing your number! ans = %d\n", to);
write(fd_req[1], "end", MAXMSG);
return ;
}
}
}
}
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>
#include <stdlib.h>
#define TIME1 200
#define TIME2 199
int apple_num(int from, int to){
if(to >= from)
return to - from;
return to + 6 - from;
}
sem_t sem_apple, sem_space;
pthread_mutex_t producer_mutex, customer_mutex;
int from = 0, to = 0;
void * producer(void *args){
int time = TIME1;
while(time--){
pthread_mutex_lock(&producer_mutex);
sem_wait(&sem_space);
to = (to + 1) % 6;
printf("生产一个，当前苹果数目%d个\n", apple_num(from, to));
sem_post(&sem_apple);
pthread_mutex_unlock(&producer_mutex);
}
}
void * customer(void *args){
int time = TIME2;
while(time--){
pthread_mutex_lock(&customer_mutex);
sem_wait(&sem_apple);
from = (from + 1) % 6;
printf("消费一个，当前苹果数目%d个\n", apple_num(from, to));
sem_post(&sem_space);
pthread_mutex_unlock(&customer_mutex);
}
}
int main(){
pthread_t id1[3], id2[3];
//int ret1, ret2;
sem_init(&sem_apple, 0, 0);
sem_init(&sem_space, 0, 5);
pthread_mutex_init(&producer_mutex, NULL);
pthread_mutex_init(&customer_mutex, NULL);
int i;
for(i = 0; i < 3; i++){
if(pthread_create(&id1[i], NULL, (void *)producer, NULL) != 0){
perror("pthread_create()");
exit(1);
}
if(pthread_create(&id2[i], NULL, (void *)customer, NULL) != 0){
perror("pthread_create()");
exit(1);
}
}
for(i = 0; i < 3; i++){
pthread_join(id1[i], NULL);
pthread_join(id2[i], NULL);
}
sem_destroy(&sem_apple);
sem_destroy(&sem_space);
return 0;
}
分享到：
相关推荐
在实现Linux串口通信时，我们通常会用到几个关键的命令行工具，例如`minicom`、`screen`或自编写的脚本程序。这些工具允许我们配置串口参数，如波特率、数据位、停止位、校验位，并进行读写操作。 以标题中提到的...
在本例中，Windows 10作为上位机，通过TCP/IP与ARM Linux设备通信。 4. **TCP/IP网络通信**： 实现两个系统间的TCP/IP通信，需要创建服务器和客户端。服务器等待客户端的连接请求，而客户端则主动发起连接。在本...
Linux环境下进行ARM/单片机串口通信设计涉及多个方面，包括Linux系统下的串口操作、ARM微处理器的串口通信配置、单片机串口通信设计、以及两者之间硬件连接和软件通信流程。以下将详细阐述这些知识点。 首先，Linux...
### Linux网络通信详解 #### 一、引言 随着互联网的发展和普及，网络通信成为现代生活中不可或缺的一部分。作为开源操作系统的佼佼者，Linux凭借其强大的网络功能，在服务器领域占据了主导地位。本章节将深入探讨...
【Linux网络通信高级编程Socket】章节主要探讨了在Linux环境下如何进行高级的网络通信编程，特别是使用Socket进行TCP/IP通信。Socket是网络编程的核心概念，它代表了一个通信端点，结合IP地址和端口号，用于标识网络...
下面以 TCP 为例，介绍几个基本的 socket 接口函数： 1. socket() 函数 int socket(int domain, int type, int protocol); socket 函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而 ...
本主题主要探讨的是如何使用C语言在Linux下实现基于socket的客户端和服务端通信，并且采用多线程技术，使得客户端和服务器可以相互发送消息而无需等待对方回应。 首先，我们来理解一下基本的socket通信流程。创建...
《LINUX设备驱动程序例》第三版是一本深入浅出介绍Linux设备驱动开发的经典书籍，书中包含了大量的实例，帮助读者理解和实践Linux驱动程序的编写。下面将详细探讨Linux设备驱动程序的一些核心概念、分类以及如何编写...
本文主要探讨了如何在基于ARM架构的Linux系统中设计和实现异步串行通信，特别以三星公司的$3C2410X处理器为例，阐述了串行通信的硬件电路和软件技术。 1. 引言 嵌入式系统是信息技术的重要组成部分，特别是在网络...
总结来说，实现Linux上的Modbus TCP协议涉及理解Modbus协议结构、使用TCP套接字进行通信以及利用libmodbus或其他相关库提供的API。通过这些步骤，你可以创建能够与Modbus设备交互的应用程序，无论是作为客户端从设备...
Linux DHCP 网络故障排除一例 本资源介绍了 Linux 操作系统中 DHCP 网络故障排除的一例，解决了 Linux 客户机无法取得 IP 地址的问题。通过分析dhcpd 服务器和 DHCP 客户机的交互过程，发现问题出在 Linux 客户机...
在Linux操作系统中，进程间的通信（IPC，Inter-Process Communication）是实现不同进程协同工作的重要机制。本示例着重探讨了一种基础的IPC形式——匿名管道。匿名管道是一种半双工（即数据只能单向流动）的数据通信...
本篇将基于提供的"Linux网络编程小例"进行深入探讨。 标题"Linux网络编程小例"暗示了我们将讨论如何在Linux操作系统上编写网络应用程序。Linux提供了一系列API，如套接字（socket）接口，用于实现TCP/IP协议栈上的...
以dterm-0.3为例，这是一个轻量级的Linux串口终端工具。安装dterm后，用户可以通过图形界面配置串口参数，并实时查看和发送数据。其使用方法通常包括以下步骤： 1. **安装dterm**：在终端中输入`sudo apt-get ...
本文以 AT24C02 为例，详细介绍了 IIC 总线的通信方式，并着重介绍了基于 ARM-Linux 的 IIC 总线设备的驱动编写。 IIC 总线的应用非常广泛，例如在智能家电、汽车电子、医疗电子等领域都有广泛的应用。同时，IIC ...
本篇文章将深入探讨Linux下的管道通信，并以C语言为例，解析如何创建和使用管道。 首先，管道的特性是半双工通信，即数据只能在一个方向上流动，不能同时双向传输。它由一个内核维护的缓冲区组成，两个进程通过共享...
本文将详细介绍Linux环境下ARM处理器（以S3C2440为例）与C8051Fxxx系列单片机进行串口通信的设计方法。 首先，串口通信的基本原理是通过串行数据线（TXD和RXD）进行数据的发送和接收，通常还包含一个共同的地线...
### Linux进程间管道通信的研究 #### 一、引言 对于多用户、多任务的操作系统而言，进程间的通信（Inter-Process Communication, IPC）是非常重要的组成部分。它为系统的有序运作奠定了基础。Linux作为一种开放源...
以QQ聊天室为例，学生们需要理解如何利用这些通信方式实现客户端和服务端的数据交换。 五、编程实践：QQ聊天室 QQ聊天室项目是课程的实践部分，它要求学生运用所学的Linux知识和编程技巧，实现一个简单的多用户...