socket_一个简单应用_源代码

socket_一个简单应用_源代码
代码文件有：
outer.cpp outer.h
socket.cpp socket.h
sockmsg.cpp sockmsg.h
linent.cpp service.cpp
outer.h:
=======
#ifndef _OUTER_H_
#define _OUTER_H_
// 数据类型定义
typedef unsigned char byte;
// 常量定义
// port
const int PORT = 52309;
// 一个message的最大长度
const int MAX_MESSAGE_LEN = 512;
const int BACKLOG = 10;
const int CLOSE_TRY_TIMES = 10;
/*
message types
*/
// get file list
const int GET_FILE_LIST = 1;
// get dir list
const int GET_DIR_LIST = 2;
// copy file
const int COPY_FILE = 3;
// close socket
const int CLOSE_SOCKET = 4;

/*
patameter types
*/
//
const int TAG_DIR = 21;
const int FILE_NAME = 11;
const int TAG_FILE = 12;
const int FILE_TEXT = 13;

// function
void hexdump(byte *data, int len);
#endif
outer.cpp:
==========
#include <iostream>
#include "outer.h"
void hexdump(byte *data, int len) {
int rows = len/16 + 1;
for (int i=0; i<rows; i++) {
if (i*16 >= len)
break;
int j;
printf("%04x: ", rows << 4);
for (j=0; (j<16)&&(i*16+j<len); j++) {
printf("%02x ", data[i*16+j]);
if (j == 7)
printf("- ");
}
printf("| ");
for (j=0; (j<16)&&(i*16+j<len); j++) {
if (isprint(data[i*16+j]))
printf("%c", data[i*16+j]);
else
printf(".");
}
printf("/n");
}
}
socket.h:
=========
/**
* $Id: Socket.h,v 1.3 2005/04/06 07:16:14 guest Exp $
*/
#include <string>
#include "outer.h"
#ifndef __SOCKET_H__
#define __SOCKET_H__
using std::string;
class Socket {
public:
/**
* Creates an unconnected socket, with the system-default
* type of SocketImpl.
*/
Socket();
/**
* Creates a stream socket and connects it to the specified
* port number on the named host.
*/
Socket(string host, int port);
/**
* Destructor
*/
virtual ~Socket();
/**
* Creates an unconnected socket, with the system-default
* type of SocketImpl.
*/
bool setup();
/**
* Closes this socket.
*/
void close();

/**
* Closes this socket.
*/
void close(int fd);
/**
* Connects this socket to the server.
*/
bool connect(string host, int port);
/**
* Listen witch this socket.
*/
bool listen();
/**
*
*/
int accept();
/**
* Returns the address to which the socket is connected.
*/
string getInetAddress();
/**
* Gets the local address to which the socket is bound.
*/
string getLocalAddress();
/**
* Returns the local port to which this socket is bound.
*/
int getLocalPort();
/**
* Returns the remote port to which this socket is connected.
*/
int getPort();
/**
* Returns the closed state of the socket.
*/
bool isClosed();
/**
* Returns the connection state of the socket.
*/
bool isConnected();
/**
* Receives a message from this socket.
*/
int recv(byte *buf, int len);
/**
* Receives a message from this socket.
*/
int recv(int new_fd, byte *buf, int len);
/**
* Sends a message through this socket.
*/
int send(const byte *msg, int len);
/**
* Sends a message through this socket.
*/
int send(int new_fd, const byte *msg, int len);
private:
int _fd;
bool _connected;
bool _closed;
};
#endif
socket.cpp:
===========
/**
* $Id: Socket.cpp,v 1.5 2005/04/06 07:16:14 guest Exp $
*/
#include <errno.h>
#include <stdio.h>
#include <winsock2.h>
#include "Socket.h"
#include "outer.h"
/**
* Creates an unconnected socket, with the system-default
* type of SocketImpl.
*/
Socket::Socket() {
setup();
_closed = false;
}
/**
* Creates a stream socket and connects it to the specified
* port number on the named host.
*/
Socket::Socket(string host, int port) {
setup();
connect(host, port);
}
/**
* Creates an unconnected socket, with the system-default
* type of SocketImpl.
*/
bool Socket::setup() {
WSADATA wsd;
_fd = WSAStartup(MAKEWORD(2,2), &wsd);
if(_fd) {
printf("WSAStartup function err!/n");
return false;
}

_connected = false;
_closed = true;
printf("Socket: WSAStartup success execute./n");
_fd = ::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_fd == -1) {
printf(strerror(errno));
return false;
}
printf("Socket: socket success execute./n");
return true;
}
/**
* Destructor
*/
Socket::~Socket() {
close();
}
/**
* Closes this socket.
*/
void Socket::close() {
if (!isClosed()) {
if (_connected) {
printf("Socket: Close connection to /"%s:%d/"/n",
getInetAddress().c_str(), getPort());
}
int trytimes = 0;
while(::closesocket(_fd) && trytimes < CLOSE_TRY_TIMES)
trytimes++;

if(trytimes == 10) {
printf("Cannot close socket!/n");
}
else {
_closed = true;
}
}
}
/**
* Closes this socket.
*/
void Socket::close(int fd) {
if (!isClosed()) {
if (_connected) {
printf("Socket: Close connection to /"%s:%d/"/n",
getInetAddress().c_str(), getPort());
}
int trytimes = 0;
while(::closesocket(fd) && trytimes < CLOSE_TRY_TIMES)
trytimes++;

if(trytimes == 10) {
printf("Cannot close socket!/n");
}
else {
_closed = true;
}
}
}
/**
* Connects this socket to the server.
*/
bool Socket::connect(string host, int port) {
struct hostent *_h = gethostbyname(host.c_str());
if (_h == 0) {
printf(strerror(h_errno));
return false;
}
struct in_addr *_addr = (struct in_addr *)_h->h_addr;
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr = *_addr;
sin.sin_port = htons(port);
if (::connect(_fd, (sockaddr *)&sin, sizeof(sin)) == SOCKET_ERROR) {
printf(strerror(errno));
return false;
}
printf("Socket: Establish the connection to /"%s:%d/"/n",
getInetAddress().c_str(), getPort());
_connected = true;
return true;
}
/**
* Listen witch this socket.
*/
bool Socket::listen()
{
struct sockaddr_in my_addr;

my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(PORT);
my_addr.sin_addr.s_addr = INADDR_ANY;

if(::bind(_fd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == SOCKET_ERROR)
{
printf(strerror(errno));
return false;
}
else
printf("bind ok!/n");
if(::listen(_fd, BACKLOG) == SOCKET_ERROR)
{
printf(strerror(errno));
return false;
}
else
printf("listen ok!/n");
return true;
}
/**
*
*/
int Socket::accept()
{
int new_fd;
struct sockaddr_in their_addr;
int sin_size = sizeof(their_addr);

printf("accepting... /n");
new_fd = ::accept(_fd,
(struct sockaddr *)&their_addr,
&sin_size);
return new_fd == SOCKET_ERROR ? -1:new_fd;
}
/**
* Returns the address to which the socket is connected.
*/
string Socket::getInetAddress() {
struct sockaddr_in sin;
//socklen_t socklen = sizeof(sin);
int socklen = sizeof(sin);
if (getpeername(_fd, (struct sockaddr *)&sin, &socklen) == -1) {
printf(strerror(errno));
return NULL;
}
return inet_ntoa(sin.sin_addr);
}
/**
* Gets the local address to which the socket is bound.
*/
string Socket::getLocalAddress() {
struct sockaddr_in sin;
//socklen_t socklen = sizeof(sin);
int socklen = sizeof(sin);
if (getsockname(_fd, (struct sockaddr *)&sin, &socklen) == -1) {
printf(strerror(errno));
return NULL;
}
return inet_ntoa(sin.sin_addr);
}
/**
* Returns the local port to which this socket is bound.
*/
int Socket::getLocalPort() {
struct sockaddr_in sin;
//socklen_t socklen = sizeof(sin);
int socklen = sizeof(sin);
if (getsockname(_fd, (struct sockaddr *)&sin, &socklen) == -1) {
printf(strerror(errno));
return -1;
}
return ntohs(sin.sin_port);
}
/**
* Returns the remote port to which this socket is connected.
*/
int Socket::getPort() {
struct sockaddr_in sin;
//socklen_t socklen = sizeof(sin);
int socklen = sizeof(sin);
if (getpeername(_fd, (struct sockaddr *)&sin, &socklen) == -1) {
printf(strerror(errno));
return NULL;
}
return ntohs(sin.sin_port);
}
/**
* Returns the closed state of the socket.
*/
bool Socket::isClosed() {
return _closed;
}
/**
* Returns the connection state of the socket.
*/
bool Socket::isConnected() {
return _connected;
}
/**
* Receives a message from this socket.
*/
int Socket::recv(int new_fd, byte *buf, int len)
{
int nb = ::recv(new_fd, (char *)buf, len, 0);
if (nb == -1) {
printf("Error! recv./n");
}
return nb;
}
/**
* Receives a message from this socket.
*/
int Socket::recv(byte *buf, int len) {
return recv(_fd, buf, len);
}
/**
* Sends a message through this socket.
*/
int Socket::send(const byte *msg, int len) {
return send(_fd, msg, len);
}
/**
* Sends a message through this socket.
*/
int Socket::send(int new_fd, const byte *msg, int len)
{
int nb = ::send(new_fd, (char *)msg, len, 0);
if (nb == -1) {
//throw SocketException(strerror(errno));
printf("Error! send./n");
}
return nb;
}
sockmsg.h
==========
//////////////////////////////////////////////////////////////////////
// A message object.
//
// filename：SockMsg.h
// struct:
// Message
// +- Protocol Version 1 byte
// +- Message type 2 bytes
// +- Message Length 2 bytes
// for ()
// +- Patameter type 2 bytes
// +- Patameter tag 1 bytes
// +- Patameter index 2 bytes
// +- Patameter data length 2 bytes
// +- Patameter data var
//
//////////////////////////////////////////////////////////////////////
#if !defined(_SOCKMSG_H_)
#define _SOCKMSG_H_
#include "outer.h"
class MsgPatameter
{
public:
MsgPatameter(byte *data, int len) {
_data = new byte[len];
memcpy(_data, data, len);
}
~MsgPatameter(){delete[] _data;}
inline int getType() const {return _data[0] << 8 | _data[1];}
inline int getTag() const {return _data[2];}
inline int getIndex() const {return _data[3] << 8 | _data[4];}
inline int getLen() const {return _data[5] << 8 | _data[6];}
byte *getData() const {return _data+7;}
private:
byte *_data;
};
class SockMsg
{
public:
/**
*
*/
SockMsg(void);
/**
*
*/
virtual ~SockMsg(void);
public:
/**
* Returns the version of the protocol used
* by this message object.
*/
int getProtocolVersion(void) const;

/**
* Returns the message length.
*/
int getMessageLength(void) const;
/**
* Returns the message length.
*/
int Length(void) const;
/**
* Returns the type of this message object.
*/
int getMessageType(void) const;
/**
* Sets the version of the protocol used.
*/
void setProtocolVersion(const int &version);
/**
* Sets the type of this message object.
*/
void setMessageType(const int &type);
/**
* Sets a patameter info in the message.
*/
void setPatameter(int type, char tag, int index, int len, const byte *data);
/**
* Sets a patameter info in the message.
*/
void setPatameter(int type, int len, const byte *data);
/**
* Sets a patameter info in the message.
*/
void setPatameter(int type);
/**
* Clear patameters from in the message.
*/
void clearPatameter(void);
/**
* Gets data of the message.
*/
byte *getData(void);
/**
*
*/
MsgPatameter * getPatameter(const int &index) const;
/**
* Print datas of this message object.
*/
void toString(void) const;
private:
/**
* Sets the message_length field.
*/
void setMessageLength(const int &length);

private:
byte *_data;
// MsgPatameter
};
#endif // !defined(_SOCKMSG_H_)
sockmsg.cpp:
============
// SockMsg.cpp: implementation of the SockMsg class.
//
//////////////////////////////////////////////////////////////////////
#include <iostream>
#include "SockMsg.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
SockMsg::SockMsg(void)
{
_data = new byte[MAX_MESSAGE_LEN];
memset(_data, 0, MAX_MESSAGE_LEN);
setProtocolVersion(1);
setMessageType(0);
setMessageLength(0);
}
SockMsg::~SockMsg(void)
{
delete[] _data;
}
/**
* Returns the version of the protocol used
* by this _message object.
*/
int SockMsg::getProtocolVersion(void) const {
return _data[0];
}
/**
* Returns the _message_length field.
*/
int SockMsg::getMessageLength(void) const {
return (_data[3] << 8) | _data[4];
}
/**
* Returns the message length.
*/
int SockMsg::Length(void) const {
return getMessageLength() + 5;
}
/**
* Returns the type of this message object.
*/
int SockMsg::getMessageType(void) const {
return (_data[1] << 8) | _data[2];
}
/**
* Sets the version of the protocol used.
*/
void SockMsg::setProtocolVersion(const int &version) {
_data[0] = version;
}
/**
* Sets the message length.
*/
void SockMsg::setMessageLength(const int &length) {
_data[3] = length >> 8;
_data[4] = length;
}
/**
* Sets the type of this message object.
*/
void SockMsg::setMessageType(const int &type) {
_data[1] = type >> 8;
_data[2] = type;
}
/**
* Sets a patameter info in the message.
*/
void SockMsg::setPatameter(int type, int len, const byte *data) {
setPatameter(type, 1, 0, len, data);
}
/**
* Sets a patameter info in the message.
*/
void SockMsg::setPatameter(int type) {
setPatameter(type, 1, 0, 0, NULL);
}
/**
* Sets a patameter info in the message.
*/
void SockMsg::setPatameter(int type, char tag, int index, int len, const byte *data) {
int len_ = getMessageLength() + 5;
_data[len_] = type >> 8;
_data[len_ + 1] = type;
_data[len_ + 2] = tag;
_data[len_ + 3] = index >> 8;
_data[len_ + 4] = index;
_data[len_ + 5] = len >> 8;
_data[len_ + 6] = len;
if (data)
memcpy(&_data[len_ + 7], data, len);
setMessageLength(len_ + len + 2);
}
/**
* Gets data of the message.
*/
byte *SockMsg::getData(void) {
return _data;
}
/**
* Clear patameters from in the message.
*/
void SockMsg::clearPatameter(void) {
setMessageLength(0);
}
/**
*
*/
MsgPatameter *SockMsg::getPatameter(const int &index) const{
int patameters_ = 5;
int len_ = getMessageLength();
int index_ = 0, patlen_;
while (len_ - patameters_ >0) {
patlen_ = _data[patameters_ + 5] << 8 | _data[patameters_ + 6];
if (index_ == index) {
MsgPatameter *patameter = new MsgPatameter(_data + patameters_, patlen_
+ 7);
return patameter;
}
patameters_ += patlen_ + 7;
index_++;
}
return NULL;
}
/**
* Print datas of this message object.
*/
void SockMsg::toString(void) const {
int patameters_ = 5;
int len_ = getMessageLength();
printf("Message info :/n");
printf(" message protocol : %d/n", getProtocolVersion());
printf(" message type : %d/n", getMessageType());
printf(" message length : %d/n", getMessageLength());
printf(" message patameter :/n");
MsgPatameter *p_pata = NULL;
for (int i=0; ; i++) {
p_pata = getPatameter(i);
if (!p_pata)
break;
printf(" patameter type : %d/n", p_pata->getType());
printf(" patameter tag : %d/n", p_pata->getTag());
printf(" patameter index : %d/n", p_pata->getIndex());
printf(" patameter data len : %d/n", p_pata->getLen());
hexdump(p_pata->getData(), p_pata->getLen());
delete p_pata;
p_pata = NULL;
}
}
client.cpp
==========
#include <stdio.h>
#include <Socket.h>
#include <SockMsg.h>
#include <string.h>
#include <iostream>
using std::cin;
int main(int argc, char **argv)
{
printf("socket of client is run .../n");
Socket s;
SockMsg msg;
if(!s.connect("dezhi", PORT)) {
printf("Not service!/n");
return 0;
}
while (1) {
printf("select opration. f(show file list), c(copy file), q(exit)./n");
char m;
cin >> m;
if (m == 'q')
break;
if (m == 'f') {
printf("select dir :");
char *dir = new char[64];
cin >> dir;

msg.setMessageType(GET_FILE_LIST);
msg.setPatameter(TAG_DIR, strlen(dir), (byte *)dir);
}
else if (m == 'c') {
printf("select file : ");
char *file = new char[64];
cin >> file;

msg.setMessageType(COPY_FILE);
msg.setPatameter(TAG_FILE, strlen(file)+1, (byte *)file);
}
else {
printf("No operation !/n");
continue;
}
s.send(msg.getData(), msg.Length());
s.recv(msg.getData(), 512);
msg.toString();
}
msg.clearPatameter();
msg.setMessageType(CLOSE_SOCKET);
s.send(msg.getData(), msg.Length());

s.close();

return 0;
}
service.cpp:
============
#include <stdio.h>
#include <Socket.h>
#include <SockMsg.h>
#include <string.h>
#include <iostream>
int main(int argc, char **argv)
{
printf("socket of service is run .../n");
Socket s;
s.listen();
SockMsg msg;
while (1) {
int new_fd = s.accept();
while (s.recv(new_fd, msg.getData(), 512) != -1) {
msg.toString();

if (msg.getMessageType() == CLOSE_SOCKET)
break;
MsgPatameter *p_pata = msg.getPatameter(0);
if (msg.getMessageType() == GET_FILE_LIST) {

if (p_pata->getType() == TAG_DIR) {
char *dir = (char *)p_pata->getData();
getfilelist(dir);
}
msg.clearPatameter();
c_file *cf = _v.begin();
for (; cf < _v.end(); cf++) {
char *va = cf->getdata();
printf("va len = %d/n", strlen(va));
msg.setPatameter(FILE_NAME, strlen(va), (byte *)va);
}
}
else if (msg.getMessageType() == COPY_FILE) {
if (p_pata->getType() == TAG_FILE) {
int len = p_pata->getLen();
char *file = (char *)p_pata->getData();

msg.clearPatameter();
FILE *f_ = fopen(file, "r");
if (!f_)
break;
byte *buf = new byte[128];
fread(buf, 128, 1, f_);
msg.setPatameter(FILE_TEXT, 128, buf);

}

}
delete p_pata;
msg.toString();
s.send(new_fd, msg.getData(), msg.Length());

}
s.close(new_fd);
}
s.close();
return 0;
}