具体程序如下：
主服务器和主客户端：
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include "utilities.h"
using namespace std;
void handpipe(int sig)
{
}
int socketListen = 0;
struct MySocketInfo
{
int socketCon; //不显示
string ipaddr;
int port; //不显示
string macAddr;
unsigned long storeCount; //存储的图像数量
string status;//状态
};
void *fun_thrAcceptHandler(void *socketListen);
void *fun_thrReceiveHandler(void *socketInfo);
void *fun_ShowState(void *tranInput);
void *fun_SendInfo(void *argv);
vector<MySocketInfo> RaspySocket;
MySocketInfo more;
MySocketInfo last;
pthread_rwlock_t rwlock_RaspySocket = PTHREAD_RWLOCK_INITIALIZER;
int main()
{
signal(SIGPIPE, handpipe);
/* 创建TCP连接的Socket套接字 */
socketListen = socket(AF_INET, SOCK_STREAM, 0);
if(socketListen < 0){
cout<< "创建TCP套接字失败"<< endl;
return -1;
}
int on = 1;
setsockopt(socketListen, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
/* 填充服务器端口地址信息，以便下面使用此地址和端口监听 */
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY); /* 这里地址使用全0，即所有 */
server_addr.sin_port=htons(6666);
if(bind(socketListen, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) != 0){
cout<< "绑定ip地址、端口号失败"<< endl;
return -2;
}
/* 开始监听相应的端口 */
if(listen(socketListen, 100) != 0){
cout<< "开启监听失败"<< endl;
return -3;
}else{
cout<< "服务器端开始监听"<< endl;
}
pthread_t thrAccept_pthread, showState_pthread;
pthread_create(&thrAccept_pthread, NULL, fun_thrAcceptHandler, &socketListen); //新建一个线程，接受设备连接
pthread_create(&showState_pthread, NULL, fun_ShowState, NULL);
pthread_t send_pthread;
pthread_create(&send_pthread, NULL, fun_SendInfo, NULL);
while (true) {
sleep(1);
}
}
void *fun_thrAcceptHandler(void *socketListen)
{
int socketCon = -1;
while(true)
{
int sockaddr_in_size = sizeof(struct sockaddr_in);
struct sockaddr_in client_addr;
int _socketListen = *((int *)socketListen);
struct timeval timeout={20,0};
setsockopt(_socketListen,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(_socketListen,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
socketCon = accept(_socketListen, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
if(socketCon >= 0)//int accept(int sockfd,struct sockaddr* addr,socklen_t* addrlen);
{ //sockfd：套接字描述符，该套接口在listen()后监听连接。addr：（可选）指针，指向一缓冲区，其中接收为通讯层所知的连接实体的地址。Addr参数的实际格式由套接口创建时所产生的地址族确定。addrlen：（可选）指针，输入参数，配合addr一起使用，指向存有addr地址长度的整型数。
printf("连接成功 ip: %s:%d , 连接套接字为：%d\n",inet_ntoa(client_addr.sin_addr), client_addr.sin_port, socketCon);
MySocketInfo socketInfo;
socketInfo.socketCon = socketCon;
socketInfo.ipaddr = inet_ntoa(client_addr.sin_addr);
socketInfo.port = client_addr.sin_port;
pthread_t thrReceive = 0;
pthread_create(&thrReceive, NULL, fun_thrReceiveHandler, &socketInfo);
}
usleep(20);
}
close(socketCon);
std::cout<< "socket 服务器监听线程退出成功"<< std::endl;
return NULL;
}
void *fun_thrReceiveHandler(void *socketInfo)
{
char buffer[1024];
long buffer_length;
MySocketInfo _socketInfo = *((MySocketInfo *)socketInfo);
while(true)
{
memset(buffer, 0x00, sizeof(buffer));
buffer_length = recv(_socketInfo.socketCon, buffer, 1024, 0); //接收信息，判断是什么设备,第一个参数为指定接收端套接字描述符；
if(buffer_length == 0)
{
printf("%s:%d 客户端关闭1\n", _socketInfo.ipaddr.c_str(), _socketInfo.port);
if(RaspySocket.size() > 0) {
vector<MySocketInfo>::iterator it;
for(it=RaspySocket.begin();it!=RaspySocket.end();it++) {
if(it->ipaddr == _socketInfo.ipaddr) {
it->status = "off-line";
}
}
}
break;
}
else if(buffer_length < 0)
{
usleep(10);
continue;
}
else
{
std::cout << "buffer: " <<buffer<< std::endl;//info_macAddress_ipAddress_505505
vector<string> tmp_status = split_c(buffer, "_");
if(tmp_status.size() == 4 && tmp_status[0] == "info") {
if(RaspySocket.size() == 0) {
_socketInfo.macAddr = tmp_status[1];
_socketInfo.ipaddr = tmp_status[2];
_socketInfo.storeCount = stol(tmp_status[3]);
_socketInfo.status = "on-line";
RaspySocket.push_back(_socketInfo);
} else {
bool flag = false;
for(int i=0;i<RaspySocket.size();i++) {
if(RaspySocket[i].macAddr == tmp_status[1]) {
RaspySocket[i].macAddr = tmp_status[1];
RaspySocket[i].ipaddr = tmp_status[2];
RaspySocket[i].storeCount = stol(tmp_status[3]);
RaspySocket[i].status = "on-line";
flag = true;
break;
}
}
if(!flag) {
_socketInfo.macAddr = tmp_status[1];
_socketInfo.ipaddr = tmp_status[2];
_socketInfo.storeCount = stol(tmp_status[3]);
_socketInfo.status = "on-line";
RaspySocket.push_back(_socketInfo);
}
}
}
}
}
printf("连接 %s:%d 客户端 的线程结束了\n", _socketInfo.ipaddr.c_str(), _socketInfo.port);
close(_socketInfo.socketCon);
return NULL;
}
void *fun_ShowState(void *tranInput) //定时刷新屏幕，显示当前设备工作情况
{
sleep(3);
while (true)
{
if(system("clear") < 0) {
sleep(1);
continue;
}
std::cout<< std::endl<< "-------------------------------------------------------------------------------------------------------------------------------------------------"<<std::endl;
time_t now; //实例化time_t结构
tm *timenow; //实例化tm结构指针
time(&now); //time函数读取现在的时间(国际标准时间非北京时间)，然后传值给now
timenow = localtime(&now); //localtime函数把从time取得的时间now换算成你电脑中的时间(就是你设置的地区)
printf("%04d-%02d-%02d %02d:%02d:%02d\n", timenow->tm_year+1900, timenow->tm_mon + 1, timenow->tm_mday, timenow->tm_hour, timenow->tm_min, timenow->tm_sec);
std::cout<< "-------------------------------------------------------------------------------------------------------------------------------------------------"<<std::endl;
std::cout << "编号\t\tmac地址\t\t\tIP地址\t\t\t图片数量\t\t状态" << std::endl;
pthread_rwlock_rdlock(&rwlock_RaspySocket);
vector<MySocketInfo> RaspySocketTemp;
if(RaspySocket.size()) {
RaspySocketTemp.push_back(RaspySocket[0]);
for(int i=1; i<RaspySocket.size(); i++) {
vector<MySocketInfo>::iterator it;
for (it = RaspySocketTemp.begin(); it != RaspySocketTemp.end(); it++) {
if(it->storeCount < RaspySocket[i].storeCount)
break;
}
if(it != RaspySocketTemp.end()) {
RaspySocketTemp.insert(it, RaspySocket[i]);
} else {
RaspySocketTemp.push_back(RaspySocket[i]);
}
}
}
pthread_rwlock_unlock(&rwlock_RaspySocket);
if(RaspySocketTemp.size() > 0) {
for (int i = 0; i < RaspySocketTemp.size(); i++)
{
printf("No.%-3d\t\t%s\t\t%s\t\t%ld\t\t\t%s\n",
i+1, RaspySocketTemp[i].macAddr.c_str(), RaspySocketTemp[i].ipaddr.c_str(),
RaspySocketTemp[i].storeCount, RaspySocketTemp[i].status.c_str());
}
if(RaspySocketTemp.size() >= 2) {
more = RaspySocketTemp[0];
last = RaspySocketTemp[RaspySocketTemp.size() - 1];
}
}
RaspySocketTemp.clear();
std::cout << "-------------------------------------------------------------------------------------------------------------------------------------------------"<<std::endl;
sleep(1);
}
std::cout << "显示进程退出成功"<<std::endl;
return 0;
}
void *fun_SendInfo(void *argv)
{
sleep(5);
while (true) {
if(!more.ipaddr.empty() && !last.ipaddr.empty() && more.status != "off-line" && last.status != "off-line") {
cout<<more.ipaddr<<" "<<last.ipaddr<<endl;
int socketfd = socket(AF_INET, SOCK_STREAM, 0); //创建TCP连接的Socket套接字
if(socketfd < 0){
std::cout<< "创建TCP连接套接字失败"<< std::endl;
close(socketfd);
continue;
}
// 填充客户端端口地址信息，以便下面使用此地址和端口监听
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
cout<<more.ipaddr<<endl;
server_addr.sin_addr.s_addr=inet_addr(more.ipaddr.c_str());
server_addr.sin_port=htons(7777);
struct timeval timeout={5,0};
setsockopt(socketfd,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(socketfd,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
printf("等待连接\n");
int res_con = connect(socketfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));
if(res_con == 0){
printf("连接成功,连接结果为：%d\n",res_con);
}
char buffer[1024] = {'0'};
sprintf(buffer, "sub_%s_%s_%ld", last.macAddr.c_str(), last.ipaddr.c_str(), last.storeCount);
std::cout<<buffer<<std::endl;
if(send(socketfd, buffer, strlen(buffer), 0) <= 0)
{
printf("信息发送失败\n");
}
close(socketfd);
}
sleep(10);
}
}
从服务器和从客户端
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
#include <vector>
#include <signal.h>
#include "utilities.h"
using namespace std;
void handpipe(int sig)
{
}
void *sendInfo(void *argv);
void *recvEmptyInfo(void *argv);
void *sendPicture(void *argv);
void *recvPicture(void *argv);
string m_idleIP;
bool m_flag=false;
int main()
{
signal(SIGPIPE, handpipe);
pthread_t send, recv;
pthread_create(&recv, NULL, recvEmptyInfo, NULL);
pthread_create(&send, NULL, sendInfo, NULL);
pthread_t sendP, recvP;
pthread_create(&recvP, NULL, recvPicture, NULL);
pthread_create(&sendP, NULL, sendPicture, NULL);
while (true) {
sleep(1);
}
return 0;
}
void *sendInfo(void *argv)
{
while (true) {
int socketCon = socket(AF_INET, SOCK_STREAM, 0); //创建TCP连接的Socket套接字
if(socketCon < 0){
std::cout<< "创建TCP连接套接字失败"<< std::endl;
return NULL;
}
// 填充客户端端口地址信息，以便下面使用此地址和端口监听
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=inet_addr("192.168.2.74");
server_addr.sin_port=htons(6666);
struct timeval timeout={20,0};
setsockopt(socketCon,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(socketCon,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
printf("等待连接\n");
int res_con = connect(socketCon,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));
if(res_con == 0){
printf("连接成功,连接结果为：%d\n",res_con);
}
char buffer[1024] = {'0'};
sprintf(buffer, "info_macAddress_ipAddress_505505");//"info_dca6321268a5_192.168.2.86_12345"); //"info_dca632bd920d_192.168.2.94_505505");
while(true){
if(send(socketCon, buffer, strlen(buffer), 0) <= 0)
{
printf("信息发送失败\n");
m_flag = false;
break;
}else {
m_flag = true;
}
sleep(1);
}
close(socketCon);
sleep(1);
}
}
void *recvEmptyInfo(void *argv) //为忙盒子，获取到不忙的盒子ip
{
/* 创建TCP连接的Socket套接字 */
int socketListen = socket(AF_INET, SOCK_STREAM, 0);
if(socketListen < 0){
cout<< "创建TCP套接字失败"<< endl;
return NULL;
}
int on = 1;
setsockopt(socketListen, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
/* 填充服务器端口地址信息，以便下面使用此地址和端口监听 */
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY); /* 这里地址使用全0，即所有 */
server_addr.sin_port=htons(7777);
if(bind(socketListen, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) != 0){
cout<< "绑定ip地址、端口号失败"<< endl;
return NULL;
}
/* 开始监听相应的端口 */
if(listen(socketListen, 100) != 0){
cout<< "开启监听失败"<< endl;
return NULL;
}else{
cout<< "服务器端开始监听"<< endl;
}
while (true) {
int sockaddr_in_size = sizeof(struct sockaddr_in);
struct sockaddr_in client_addr;
struct timeval timeout={20,0};
setsockopt(socketListen,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(socketListen,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
int socketfd = accept(socketListen, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
if(socketfd >= 0)//int accept(int sockfd,struct sockaddr* addr,socklen_t* addrlen);
{ //sockfd：套接字描述符，该套接口在listen()后监听连接。addr：（可选）指针，指向一缓冲区，其中接收为通讯层所知的连接实体的地址。Addr参数的实际格式由套接口创建时所产生的地址族确定。addrlen：（可选）指针，输入参数，配合addr一起使用，指向存有addr地址长度的整型数。
printf("连接成功 ip: %s:%d , 连接套接字为：%d\n",inet_ntoa(client_addr.sin_addr), client_addr.sin_port, socketfd);
char buffer[1024];
long buffer_length;
memset(buffer, 0x00, sizeof(buffer));
buffer_length = recv(socketfd, buffer, 1024, 0); //接收信息，判断是什么设备,第一个参数为指定接收端套接字描述符；
if(buffer_length == 0)
{
printf("%s:%d 客户端关闭1\n", inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
break;
}
else if(buffer_length < 0)
{
usleep(10);
continue;
}
else
{
std::cout << "buffer: " <<buffer<< std::endl;//info_macAddress_ipAddress_505505
vector<string> info = split_c(buffer, "_");
m_idleIP = info[2];
cout<<"idle ip: "<<m_idleIP<<endl;
}
printf("连接 %s:%d 客户端 的线程结束了\n", inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
}
}
close(socketListen);
}
void *sendPicture(void *argv)
{
while (true) {
if(!m_idleIP.empty() && m_flag){
int sockets = socket(AF_INET, SOCK_STREAM, 0); //创建TCP连接的Socket套接字
if(sockets < 0){
std::cout<< "创建TCP连接套接字失败"<< std::endl;
return NULL;
}
// 填充客户端端口地址信息，以便下面使用此地址和端口监听
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=inet_addr(m_idleIP.c_str());
server_addr.sin_port=htons(8888);
struct timeval timeout={20,0};
setsockopt(sockets,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(sockets,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
printf("等待连接\n");
int res_con = connect(sockets,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr));
if(res_con == 0){
printf("连接成功,连接结果为：%d\n",res_con);
}
char buffer[1024] = {'0'};
sprintf(buffer, "picture_date_md5_data");
std::cout<<"send buffer: "<<buffer<<std::endl;
if(send(sockets, buffer, strlen(buffer), 0) <= 0)
{
printf("信息发送失败\n");
}
close(sockets);
printf(" %s:8888 客户端 的线程结束了\n", m_idleIP.c_str());
}
sleep(1);
}
}
void *recvPicture(void *argv) //为忙盒子，获取到不忙的盒子ip
{
/* 创建TCP连接的Socket套接字 */
int socketl = socket(AF_INET, SOCK_STREAM, 0);
if(socketl < 0){
cout<< "创建TCP套接字失败"<< endl;
return NULL;
}
int on = 1;
setsockopt(socketl, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
/* 填充服务器端口地址信息，以便下面使用此地址和端口监听 */
struct sockaddr_in server_addr;
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY); /* 这里地址使用全0，即所有 */
server_addr.sin_port=htons(8888);
if(bind(socketl, (struct sockaddr *)&server_addr,sizeof(struct sockaddr)) != 0){
cout<< "绑定ip地址、端口号失败"<< endl;
return NULL;
}
/* 开始监听相应的端口 */
if(listen(socketl, 100) != 0){
cout<< "开启监听失败"<< endl;
return NULL;
}else{
cout<< "服务器端开始监听"<< endl;
}
while (true) {
int sockaddr_in_size = sizeof(struct sockaddr_in);
struct sockaddr_in client_addr;
struct timeval timeout={20,0};
setsockopt(socketl,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout));
setsockopt(socketl,SOL_SOCKET,SO_RCVTIMEO,(const char*)&timeout,sizeof(timeout));
int socketf = accept(socketl, (struct sockaddr *)(&client_addr), (socklen_t *)(&sockaddr_in_size));
if(socketf >= 0)//int accept(int sockfd,struct sockaddr* addr,socklen_t* addrlen);
{ //sockfd：套接字描述符，该套接口在listen()后监听连接。addr：（可选）指针，指向一缓冲区，其中接收为通讯层所知的连接实体的地址。Addr参数的实际格式由套接口创建时所产生的地址族确定。addrlen：（可选）指针，输入参数，配合addr一起使用，指向存有addr地址长度的整型数。
printf("连接成功 ip: %s:%d , 连接套接字为：%d\n",inet_ntoa(client_addr.sin_addr), client_addr.sin_port, socketf);
char buffer[1024];
long buffer_length;
memset(buffer, 0x00, sizeof(buffer));
buffer_length = recv(socketf, buffer, 1024, 0); //接收信息，判断是什么设备,第一个参数为指定接收端套接字描述符；
if(buffer_length == 0)
{
printf("%s:%d 客户端关闭1\n", inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
break;
}
else if(buffer_length < 0)
{
usleep(10);
continue;
}
else
{
std::cout << "buffer: " <<buffer<< std::endl;//info_macAddress_ipAddress_505505
}
printf("连接 %s:%d 客户端 的线程结束了\n", inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
}
}
close(socketl);
}
将字符串分段函数：
.h函数
#include <stdio.h>
#include<vector>
#include <iostream>
using namespace std;
vector<string> split_c(const string &s, const string &seperator);
vector<string> split_c(const char *ss, const string &seperator);
.cpp文件
vector<string> split_c(const string &s, const string &seperator)
{
vector<string> result;
typedef string::size_type string_size;
string_size i = 0;
while(i != s.size())
{
//找到字符串中首个不等于分隔符的字母；
int flag = 0;
while(i != s.size() && flag == 0){
flag = 1;
for(string_size x = 0; x < seperator.size(); ++x)
{
if(s[i] == seperator[x])
{
++i;
flag = 0;
break;
}
}
}
//找到又一个分隔符，将两个分隔符之间的字符串取出；
flag = 0;
string_size j = i;
while(j != s.size() && flag == 0)
{
for(string_size x = 0; x < seperator.size(); ++x)
if(s[j] == seperator[x])
{
flag = 1;
break;
}
if(flag == 0)
++j;
}
if(i != j)
{
result.push_back(s.substr(i, j-i));
i = j;
}
}
return result;
}
vector<string> split_c(const char *ss, const string &seperator)
{
string s = ss;
vector<string> result;
typedef string::size_type string_size;
string_size i = 0;
while(i != s.size())
{
//找到字符串中首个不等于分隔符的字母；
int flag = 0;
while(i != s.size() && flag == 0){
flag = 1;
for(string_size x = 0; x < seperator.size(); ++x)
{
if(s[i] == seperator[x])
{
++i;
flag = 0;
break;
}
}
}
//找到又一个分隔符，将两个分隔符之间的字符串取出；
flag = 0;
string_size j = i;
while(j != s.size() && flag == 0)
{
for(string_size x = 0; x < seperator.size(); ++x)
if(s[j] == seperator[x])
{
flag = 1;
break;
}
if(flag == 0)
++j;
}
if(i != j)
{
result.push_back(s.substr(i, j-i));
i = j;
}
}
return result;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
