一个简单的文件共享工程 -- TMServer

TMServer文件夹中文件:

TMServer.h:

#ifndef __TCP_MULTIPLEXING_SERVER_H__
#define __TCP_MULTIPLEXING_SERVER_H__

#include <dirent.h>
#include <sys/select.h>
#include <vector>
using std::vector;

#include "../TConnection/TConnection.h"
#include "../Head/Uncopy.h"

class TMServer : public TConnection, public Uncopy
{
public:
TMServer(const char * host, const char * serv);
virtual ~TMServer();

public:
void mainloop();

protected:
struct ConnNode
{
public:
ConnNode(int connfd, unsigned short ulen);
ConnNode(const ConnNode &);
~ConnNode();
ConnNode & operator = (const ConnNode &);

public:
void destroy();

public:
int sockfd;
bool rcvdat;
unsigned short lowlen;
char cwd[PATH_MAX + 1];

static char root[PATH_MAX + 1];
};

protected:
virtual bool handle(ConnNode & conn, unsigned char cmd,
char * data, unsigned short uslen) = 0;

protected:
bool accept();
void close(int & index);
bool checksock();
void adjustcwd();

protected:
int m_listenfd;
vector<ConnNode> m_acceptcn;

int m_maxfd;
fd_set m_masterset;
};

#endif
TMServer.cpp:
#include <errno.h>
#include <dirent.h>
#include <cstdio>
#include <cstring>
#include <cassert>

#include "../ByteStream/ByteStream.h"
#include "../Head/Command.h"
#include "TMServer.h"

char TMServer::ConnNode::root[PATH_MAX + 1];

TMServer::TMServer(const char * host, const char * serv) : m_listenfd(-1)
{
m_listenfd = listen(host, serv);
FD_ZERO(&m_masterset);
FD_SET(m_listenfd, &m_masterset);
m_maxfd = m_listenfd;

getcwd(ConnNode::root, PATH_MAX + 1);
if ('/' != ConnNode::root[strlen(ConnNode::root) - 1]) {
strcat(ConnNode::root, "/share/");
}
else {
strcat(ConnNode::root, "share/");
}
mkdir(ConnNode::root, DIR_MODE);
}

TMServer::~TMServer()
{
if (-1 != m_listenfd) {
close(m_listenfd);
}

vector<ConnNode>::iterator iter = m_acceptcn.begin();
while (m_acceptcn.end() != iter) {
iter->destroy();
++iter;
}
}

void TMServer::mainloop()
{
int nsel;
fd_set rset;
char buff[BUFFSIZ];

for ( ; ; ) {
rset = m_masterset;
if (-1 == (nsel = select(m_maxfd + 1, &rset, NULL, NULL, NULL))) {
printf("select error: %s\n", strerror(errno));
if (!checksock()) {
break;
}
break;
continue;
}

if (FD_ISSET(m_listenfd, &rset)) {
accept();
if (0 == --nsel) {
continue;
}
}

for (int i = 0; i < m_acceptcn.size() && nsel > 0; ++i) {
ConnNode & conn = m_acceptcn[i];
if (FD_ISSET(conn.sockfd, &rset)) {
--nsel;
if (!conn.rcvdat) {
assert(sizeof(unsigned short) == conn.lowlen);
if (!recv(conn.sockfd, buff, conn.lowlen)) {
close(i);
continue;
}
IBStream is(buff, conn.lowlen);
is >> conn.lowlen;
assert(conn.lowlen > 0);
if (!setrcvlow(conn.sockfd, conn.lowlen)) {
close(i);
continue;
}
conn.rcvdat = true;
}
else {
assert(sizeof(unsigned char) <= conn.lowlen);
if (!recv(conn.sockfd, buff, conn.lowlen)) {
close(i);
continue;
}
IBStream is(buff, conn.lowlen);
unsigned char cmd;
is >> cmd;
if (!handle(conn, cmd, buff + is.tell(),
conn.lowlen - is.tell())) {
close(i);
continue;
}
conn.lowlen = sizeof(unsigned short);
if (!setrcvlow(conn.sockfd, conn.lowlen)) {
close(i);
continue;
}
conn.rcvdat = false;
}
}
}
}
}

bool TMServer::accept()
{
int sockfd;

if (-1 == (sockfd = TConnection::accept(m_listenfd))) {
return(false);
}

if (!setrcvlow(sockfd, sizeof(unsigned short))) {
::close(sockfd);
return(false);
}
setsndbuf(sockfd, 16384);
setrcvbuf(sockfd, 16384);

FD_SET(sockfd, &m_masterset);
if (sockfd > m_maxfd) {
m_maxfd = sockfd;
}

m_acceptcn.push_back(ConnNode(sockfd, sizeof(unsigned short)));

printf("new client connected\n");

return(true);
}

void TMServer::close(int & index)
{
ConnNode & conn = m_acceptcn[index];

if (-1 != conn.sockfd) {
FD_CLR(conn.sockfd, &m_masterset);
}
conn.destroy();

int ilast = m_acceptcn.size() - 1;
if (ilast > index) {
ConnNode & last = m_acceptcn[ilast];
conn = last;
last.sockfd = -1;
}

m_acceptcn.pop_back();

--index;

printf("close bad connection\n");
}

bool TMServer::checksock()
{
struct stat sbuf;
if (-1 == fstat(m_listenfd, &sbuf)) {
printf("listen socket except\n");
return(false);
}
for (int i = 0; i < m_acceptcn.size(); ++i) {
ConnNode & conn = m_acceptcn[i];
if (-1 == fstat(conn.sockfd, &sbuf)) {
close(i);
}
}
return(true);
}

void TMServer::adjustcwd()
{
struct stat sbuf;
vector<ConnNode>::iterator iter = m_acceptcn.begin();
while (m_acceptcn.end() != iter) {
if (-1 == lstat(iter->cwd, &sbuf)) {
strcpy(iter->cwd, ConnNode::root);
}
++iter;
}
}

TMServer::ConnNode::ConnNode(int connfd, unsigned short ulen)
: sockfd(connfd), rcvdat(false), lowlen(ulen)
{
strcpy(cwd, root);
}

TMServer::ConnNode::ConnNode(const ConnNode & other)
: sockfd(other.sockfd), rcvdat(other.rcvdat), lowlen(other.lowlen)
{
strcpy(cwd, other.cwd);
}

TMServer::ConnNode::~ConnNode()
{
/* do not call destory() */
}

TMServer::ConnNode & TMServer::ConnNode::operator = (const ConnNode & other)
{
if (&other != this) {
destroy();
sockfd = other.sockfd;
rcvdat = other.rcvdat;
lowlen = other.lowlen;
strcpy(cwd, other.cwd);
}
return(*this);
}

void TMServer::ConnNode::destroy()
{
if (-1 != sockfd) {
::close(sockfd);
sockfd = -1;
}
}