linux下C＋＋网络编程

[wangdingguo1987]

各为大侠，。。我刚刚毕业。。到公司上班有己天了。。。公司要我些一个多线程的测试程序
要求是：单客某一户端发送消息给服务端时。服务端把这个客户发送来的信息 转发给其他的客户，，发送这信息的客户不发
主要代码如下：
#include "Server.h"

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <iostream>
#include <string.h>

using namespace std;

//------------------------------------------------------------------
Server::Server() //初始化互斥事件，信号量
{
pthread_mutex_init(&mutex,NULL);

sem_init(&sem_r,0,10);
sem_init(&sem_s,0,0);
}

//------------------------------------------------------------------

void Server::Start()
{
pthread_create(&pth_s,NULL,SendMessageThread,this);

Initialize();
}
//------------------------------------------------------------------
void* Server::SendMessageThread(void* param)
{
Server* server = (Server *)param;
server->SendMessage(server);

return NULL;
}

//------------------------------------------------------------------

void Server::SendMessage(Server* server)
{
while(1)
{
sem_wait(&sem_s);
int list_len = list.GetLength();


int tNewfd,tReceivefd;
Data data_nod;
//pthread_mutex_lock(&mutex);
//// pData = queue.OutQueue();
data_nod=Message_nod.MessageOut();
//int queue_len = queue.Queuelength();
//pthread_mutex_unlock(&mutex);


tReceivefd =data_nod.fd;

//cout << "Received fd = " << tReceivefd << endl;

pthread_mutex_lock(&mutex);
for(int i = 1; i <= list_len; i++) //判断是不是本机如果不是就发送
{
list.GetNodeData(i,tNewfd);

if(tNewfd != tReceivefd)
{
write(tNewfd,data_nod.Msge,sizeof(data_nod.Msge));

cout << "Send to client successful! fd = " << tNewfd << endl;;
}
//}
}
//// delete pData;
pthread_mutex_unlock(&mutex);

sem_post(&sem_r);
}
}

//------------------------------------------------------------------
void Server::Initialize() //套结字初始化
{
sock_fd = socket(AF_INET,SOCK_STREAM,0);

if(sock_fd < 0)
{
perror("socket fail!" );
exit(-1);
}

servaddr.sin_family = AF_INET;
servaddr.sin_port = ntohs(atoi(PORT));
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
bzero(&(servaddr.sin_zero), 8);

if (bind(sock_fd, (struct sockaddr*) &servaddr,sizeof(struct sockaddr)) < 0)
{
perror("bind fail! ");
exit(-1);
}

if(listen(sock_fd,MAX_Num) < 0)
{
perror("listen fail!" );
exit(-1);
}
cout << "listenning......" << endl;

socklen_t sin_size = sizeof(desetaddr);
while(1)
{

new_fd = accept(sock_fd,(struct sockaddr *)&desetaddr,&sin_size);
if(new_fd < 0)
{
perror("accept fail!" );
exit(-1);
}
cout << "\nA client has connected to me "
<< inet_ntoa(desetaddr.sin_addr)
<< ":" << ntohs(desetaddr.sin_port)
<< endl;

pthread_mutex_lock(&mutex);

list.InsertNode(new_fd);

pthread_mutex_unlock(&mutex);

pthread_create(&pth_r,NULL,ReadMessageThread,this); //每当一个用户连接时就创建一个读数据的线程
}


}
//------------------------------------------------------------------

void* Server::ReadMessageThread(void* param)
{
Server* server = (Server *)param;
server->ReadMessage(server);

return NULL;
}
//------------------------------------------------------------------

void Server::ReadMessage(Server* server)
{
int fd = server->new_fd;

char buf[MSG_SIZE];
int len;

while(1)
{
sem_wait(&sem_r);
if ((len = read(fd, buf, MSG_SIZE)) == -1)
{
perror("read fail!");
pthread_exit(NULL);
}
else if (len == 0)
{
cout << "Current client has disconnected to me" << endl;


list.DeleteNode(fd);

pthread_exit(NULL);
}

buf[len] = '\0';
Data date;
date.fd=fd;
strcpy(date.Msge,buf);

cout << "\nRECEIVE: " << buf
<< " receive fd = " << fd << endl;

//pthread_mutex_lock(&mutex);
Message_nod.MessageInsert(date); //把客户端发过来的信息存入Message里面
//pthread_mutex_unlock(&mutex);

//delete data;
sem_post(&sem_s);
}
}
//------------------------------------------------------------------

Server::~Server()
{
//close(sock_fd);

//pthread_join(pth_r,NULL);
// pthread_join(pth_s,NULL);
}
void Server::GetPort_Max_Num(char *str,char * Max)
{
strcpy(str,PORT);
MAX_Num=atoi(Max);
}
//---------------------------------------------------------------------
//int Server::charT0Int(char *str)
//{

//}

#include <iostream>
#include "Server.h"


int main(int argc,char *argv[])
{
char Pt[10],Max[3];
Server *server = new Server();
cout<<"please input Port!"<<endl;
cin>>Pt;
cout<<"please input Max nuber!"<<endl;
cin>>Max;
server->GetPort_Max_Num(Pt,Max);
server->Initialize();

return 0;
}
上面有一个list 是存fd的
message 书存信息的
我可以肯定客户段没问题。。我测试过了。。

[猫已经找不回了]

mark先

[npwd]

编译没问题。。。可以到监听 到等待客户端的连接。
不过客户段就是连不上。。connecet fiale

[rgmlkthh]

我也想学习。

[haolong159]

我是什么等级？

[amossavez]

mark

[juicee]

mark

[bonny95]

代码有点麻烦，建议楼主还是好好看看C Socket编程方面的书，慢慢调。
祝你好运！

[睡在床板下_]

这个你可以写一个非常简单的socket 监听程序啊，排除是对端的原因，然后一步一步定位

[liumingrong]

考虑一下服务器端系统防火墙
是不是开放了你绑定的端口

[chin_chen]

参考一下这个
http://www.kuqin.com/networkprog/20080512/8361.html


面向连接的客户程序使用Connect函数来配置socket并与远端服务器建立一个TCP连接，其函数原型为：
　　 int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
Sockfd 是socket函数返回的socket描述符；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度。 Connect函数在出现错误时返回-1，并且设置errno为相应的错误码。进行客户端程序设计无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候到打断口。
　　 Connect函数启动和远端主机的直接连接。只有面向连接的客户程序使用socket时才需要将此socket与远端主机相连。无连接协议从不建立直接连接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客户的请求。
　　 Listen函数使socket处于被动的监听模式，并为该socket建立一个输入数据队列，将到达的服务请求保存在此队列中，直到程序处理它们。
　　 int listen(int sockfd， int backlog);
Sockfd 是Socket系统调用返回的socket 描述符；backlog指定在请求队列中允许的最大请求数，进入的连接请求将在队列中等待accept()它们（参考下文）。Backlog对队列中等待服务的请求的数目进行了限制，大多数系统缺省值为20。如果一个服务请求到来时，输入队列已满，该socket将拒绝连接请求，客户将收到一个出错信息。
当出现错误时listen函数返回-1，并置相应的errno错误码。
　　 accept()函数让服务器接收客户的连接请求。在建立好输入队列后，服务器就调用accept函数，然后睡眠并等待客户的连接请求。
　　 int accept(int sockfd, void *addr, int *addrlen);
　　 sockfd是被监听的socket描述符，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提出连接请求服务的主机的信息（某台主机从某个端口发出该请求）；addrten通常为一个指向值为sizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数返回-1并置相应的errno值。
　　首先，当accept函数监视的 socket收到连接请求时，socket执行体将建立一个新的socket，执行体将这个新socket和请求连接进程的地址联系起来，收到服务请求的初始socket仍可以继续在以前的 socket上监听，同时可以在新的socket描述符上进行数据传输操作。

数据传输
　　 Send()和recv()这两个函数用于面向连接的socket上进行数据传输。
　　 Send()函数原型为：
　　 int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述符；msg是一个指向要发送数据的指针；Len是以字节为单位的数据的长度；flags一般情况下置为0（关于该参数的用法可参照man手册）。
　　 Send()函数返回实际上发送出的字节数，可能会少于你希望发送的数据。在程序中应该将send()的返回值与欲发送的字节数进行比较。当send()返回值与len不匹配时，应该对这种情况进行处理。
char *msg = "Hello!";
int len, bytes_sent;
……
len = strlen(msg);
bytes_sent = send(sockfd, msg,len,0);
……
　　 recv()函数原型为：
　　 int recv(int sockfd,void *buf,int len,unsigned int flags);
　　 Sockfd是接受数据的socket描述符；buf 是存放接收数据的缓冲区；len是缓冲的长度。Flags也被置为0。Recv()返回实际上接收的字节数，当出现错误时，返回-1并置相应的errno值。
Sendto()和recvfrom()用于在无连接的数据报socket方式下进行数据传输。由于本地socket并没有与远端机器建立连接，所以在发送数据时应指明目的地址。
sendto()函数原型为：
　　 int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);
　　该函数比send()函数多了两个参数，to表示目地机的IP地址和端口号信息，而tolen常常被赋值为sizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时返回-1。
　　 Recvfrom()函数原型为：
　　 int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);
　　 from是一个struct sockaddr类型的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()返回时，fromlen包含实际存入from中的数据字节数。Recvfrom()函数返回接收到的字节数或当出现错误时返回-1，并置相应的errno。
如果你对数据报socket调用了connect()函数时，你也可以利用send()和recv()进行数据传输，但该socket仍然是数据报socket，并且利用传输层的UDP服务。但在发送或接收数据报时，内核会自动为之加上目地和源地址信息。

结束传输
　　当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作：
close(sockfd);
　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据，直至读入所有数据。
　　 int shutdown(int sockfd,int how);
　　 Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式：
　　 ·0-------不允许继续接收数据
　　 ·1-------不允许继续发送数据
　　 ·2-------不允许继续发送和接收数据，
　　 ·均为允许则调用close ()
　　 shutdown在操作成功时返回0，在出现错误时返回-1并置相应errno。

Socket编程实例
　　 代码实例中的服务器通过socket连接向客户端发送字符串"Hello, you are connected!"。只要在服务器上运行该服务器软件，在客户端运行客户软件，客户端就会收到该字符串。
　　 该服务器软件代码如下：
#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 SERVPORT 3333 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{
　 int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */
　 struct sockaddr_in my_addr; /* 本机地址信息 */
　 struct sockaddr_in remote_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);
　 }
　 while(1) {
　　 sin_size = sizeof(struct sockaddr_in);
　　 if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) {
　 　 　 perror("accept出错");
　 　 　 continue;
　 　}
　　 printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
　 　if (!fork()) { /* 子进程代码段 */
　　 　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 　 perror("send出错！");
　 　 　close(client_fd);
　 　 　exit(0);
　 　}
　　 close(client_fd);
　　 }
　 }
}
　　服务器的工作流程是这样的：首先调用socket函数创建一个Socket，然后调用bind函数将其与本机地址以及一个本地端口号绑定，然后调用 listen在相应的socket上监听，当accpet接收到一个连接服务请求时，将生成一个新的socket。服务器显示该客户机的IP地址，并通过新的socket向客户端发送字符串"Hello，you are connected!"。最后关闭该socket。
　　代码实例中的fork()函数生成一个子进程来处理数据传输部分，fork()语句对于子进程返回的值为0。所以包含fork函数的if语句是子进程代码部分，它与if语句后面的父进程代码部分是并发执行的。

[执假以为真]

你在哪个公司啊？

[youdang45]

lz服务器用的什么端口号进行的监听啊？

[kingsun555]

编程风格极差
void Server::Initialize() //套结字初始化

这个函数做的仅仅是初始化吗？

[npwd]

经过几天的郁闷。。搞定了。。谢谢大家