久久福利片,久久精品国产亚洲77777,日韩精品久久久久久

TCP�q�接关闭状态�{换图

Thu, 13 Mar 2014 05:22:00 GMT

摘要: tcp�q�接断开状态�{换图阅读全文

�?/a> 2014-03-13 13:22 发表评论

Fri, 10 Oct 2008 08:34:00 GMT

摘要: Windows�|�络应用中，对于服务端我们一般会选择Windows提供的IO模型�Q�如完成端口模型IOCP�?
对于客户端需要主动连接多个不同IP的TCP的情况（10或更多）�Q�那么��用什么模型比较好呢？阅读全文

�?/a> 2008-10-10 16:34 发表评论

Winsock的两�U�I/O模式

Tue, 26 Feb 2008 07:39:00 GMT

��d��模式�Q�执�?/span>I/O操作完成前会一直进行等待，不会��控制权交给�E�序。套接字默认为阻塞模式。可以通过多线�E�技术进行处理�?/span>
非阻塞模式：执行I/O操作�Ӟ��Winsock函数会返回�ƈ交出控制权。这�U�模式��?/span> ��h��比较复杂�Q�因为函数在没有�q�行完成��p��行返回，会不断地�q�回 WSAEWOULDBLOCK错误。但功能强大�?/span>

�?/a> 2008-02-26 15:39 发表评论

�|�络�~�程基础

Mon, 25 Feb 2008 05:40:00 GMT

Socket �~�程最基本的模型就�?Berkeley Socket

具体的实��C��是按这个流�E�图来做的，�q�里重点是服务端的实现�?/p>

int APIENTRY _tWinMain(HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPTSTR     lpCmdLine,
                     int        nCmdShow)
{
            ofstream logfile("LogFile.txt");
           //Initialize winsock
            WSADATA wsaData;
            int iResult = WSAStartup( MAKEWORD(2,2), &wsaData);
            if(iResult != NO_ERROR)
             {
                     logfile<<"Error at WSAStartup() ";
                     logfile.close();
                    return 1;
             }
            else
                    logfile<<"Initialize WSAStartup OK!";

             // Create a socket.
             SOCKET serverSocket;
             serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

             if(serverSocket == INVALID_SOCKET)
              {
                      logfile<<"Error at socket():"<<WSAGetLastError()<<endl;;
                      logfile.close();
                      WSACleanup();
                      return 1;
              }
             else
             {
                      logfile<<"Create socket OK!";
              }

            // Bind the socket.
              sockaddr_in service;

              service.sin_family=AF_INET;
              service.sin_addr.s_addr=inet_addr(HostIp.c_str());
              service.sin_port=htons(PORT);

              if (bind(serverSocket,(SOCKADDR*)&service,sizeof(service))==SOCKET_ERROR)
              {
                       logfile<<"bind() failed"<<GetLastError()<<endl;
                       closesocket(serverSocket);
                       logfile.close();
                      return 1;
              }
             else
              {
             logfile<<"Binding OK!"<<endl;
               }


              // Listen on the socket.
               if(listen(serverSocket,1)==SOCKET_ERROR)
               {
                       logfile<<"Error listening on socket"<<GetLastError()<<endl;
                       logfile.close();
                }
               else
                {
                       logfile<<"Listening..."<<endl;
                 }

                // Accept connections.
                 SOCKET clientSocket;
                 sockaddr_in clientAddr;
                int clientAddrLen=sizeof(clientAddr);

                while(true)
                 {
                            clientSocket = SOCKET_ERROR;
                           while(clientSocket==SOCKET_ERROR)
                            {
                                   clientSocket=accept(serverSocket,(struct sockaddr*)&clientAddr,&clientAddrLen);
                             }
                            ReceiveData(clientSocket);
                   }

                   closesocket(serverSocket);
                   closesocket(clientSocket);

                  return 0;
}

//Receive the data
void ReceiveData(SOCKET& clientSocket)
{
            int bytesSent;
            int bytesRecv=SOCKET_ERROR;
            string sendbuf="";
            char recvbuf[32]="";

            while(bytesRecv ==SOCKET_ERROR)
             {
                       bytesRecv=recv(clientSocket,recvbuf,32,0);

                        sendbuf="Received: "+(string)recvbuf;
                        bytesSent=send(clientSocket,sendbuf.c_str(),(unsigned int)(sendbuf.size()),0);

                        bytesRecv=SOCKET_ERROR;
                        memset(recvbuf,'\0',32);

}

return;

}

在接收客��L��发来数据的地方要做成��d�@环，如果需要断开�q�接�Q�则由客��h��发送特定的消息然后�q�行处理。还有需要注意的是上面的HostIp是本机的IP地址�Q�PORT是套接字需要绑定的端口�?/p>

�?/a> 2008-02-25 13:40 发表评论

在vc中通过�q�接池操作mysql(api方式)�Q�附c++讉K��mysql的封装类

Thu, 21 Feb 2008 07:10:00 GMT

在有大量节点讉K��的数据库设计�?�l�常要��用到�q�接池来��理所有的�q�接.
一般方法是:建立两个�q�接句柄队列,�I�闲的等待��用的队列和正在��用的队列.
当要查询时先从空闲队列中获取一个句�?插入到正在��用的队列,再用�q�个句柄做数据库操作,完毕后一定要从��用队列中删除,再插入到�I�闲队列.
代码如下�Q?br>MySQLMan.h
// MySQLMan.h: interface for the CMySQLMan class.
//
//////////////////////////////////////////////////////////////////////
#include
#pragma comment(lib,"libmySQL.lib")

#include

typedef std::list CONNECTION_HANDLE_LIST;
typedef std::list::iterator ITER_CONNECTION_HANDLE_LIST;

#define CONNECTION_NUM 10 //同时打开的连接数

class CMySQLMan
{
public:
CMySQLMan();
CMySQLMan(const char *host, const char *user, const char *password, const char *db, unsigned int port=3306);
virtual ~CMySQLMan();

public:
bool ConnectDB();      //�q�接数据�?br> MYSQL_RES* SelectRecord(const char *szSql); //选择记录�Q�返回结果集
bool SelectDB(const char *szDB);  //选择数据�?br> bool UpdateRecord(const char *szSql); //更新记录
bool InsertRecord(const char *szSql); //插入记录
bool DelRecord(const char *szSql);  //删除记录

BOOL IsEnd(MYSQL_RES *myquery);       //是否最�?br> void SeekData(MYSQL_RES *myquery, int offset);    //查找指定数据
void FreeRecord(MYSQL_RES *myquery);      //释放�l�果�?br> unsigned int GetFieldNum(MYSQL_RES *myquery);    //得到字段�?br> MYSQL_ROW GetRecord(MYSQL_RES *myquery);     //得到�l�果�Q�一个记录）
my_ulonglong GetRowNum(MYSQL_RES *myquery);    //得到记录�?br> char* OutErrors(MYSQL* pMySql);      //输出错误信息

char* GetState();      //服务器状�?br> char* GetServerInfo();     //服务器信�?br> int GetProtocolInfo();     //协议信息
char* GetHostInfo();     //��L��信息
char* GetClientInfo();     //客户��Z��?br> char* GetFieldName(MYSQL_RES *myquery, int FieldNum);  //字段�?/p>

bool LockTable(const char *TableName, const char *Priority); //对特定表加锁
bool UnlockTable();      //解锁
bool SetCharset();
//int CreateDB(char *db);    //创徏数据库，�q�回错误信息
//int DropDB(char *db);     //删除数据�?�q�回错误信息

MYSQL* GetIdleMySql(); //提取一个空闲句柄供使用
void SetIdleMysql(MYSQL* pMySql); //从��用队列中释放一个��用完毕的句柄�Q�插入到�I�闲队列

public:
//MYSQL m_mysql; //数据库连接句�?br> MYSQL_ROW m_row; //记录�?单行)
MYSQL_FIELD *m_field; //字段信息�Q�结构体�Q?/p>

//创徏两个队列
CONNECTION_HANDLE_LIST m_lsBusyList; //正在使用的连接句�?br> CONNECTION_HANDLE_LIST m_lsIdleList; //未��用的�q�接句柄

CRITICAL_SECTION m_csList;

public:
char m_host[20];   //��L��
char m_user[20];   //用户�?br> char m_password[20];  //密码
char m_db[20];    //数据库名
unsigned int m_port;  //端口
};

MySQLMan.cpp
// MySQLMan.cpp: implementation of the MySQLMan class.
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "MySQLMan.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMySQLMan::CMySQLMan()
{

}

CMySQLMan::CMySQLMan(const char *host, const char *user, const char *password, const char *db, unsigned int port/* =3306 */)
{
strcpy(m_host, host);
strcpy(m_user, user);
strcpy(m_password, password);
strcpy(m_db, db);
m_port = port;

InitializeCriticalSection(&m_csList);
}

CMySQLMan::~CMySQLMan()
{
for (ITER_CONNECTION_HANDLE_LIST iter=m_lsBusyList.begin(); iter != m_lsBusyList.end(); iter++)
{
mysql_close((*iter));
}

for (ITER_CONNECTION_HANDLE_LIST iter=m_lsIdleList.begin(); iter != m_lsIdleList.end(); iter++)
{
mysql_close((*iter));
}

DeleteCriticalSection(&m_csList);
}

bool CMySQLMan::ConnectDB()
{
//同时打开CONNECTION_NUM个连�?br> try
{
  for (int i=0; i  {
   MYSQL *pMySql = mysql_init((MYSQL*)NULL);
   if (pMySql != NULL)
   {
    if (!mysql_real_connect(pMySql,m_host,m_user,m_password,m_db,m_port,NULL,0))
    {
     OutErrors(pMySql);
     return false;
    }
    m_lsIdleList.push_back(pMySql);
   }
  }
}
catch (...)
{
  return false;
}
return true;
}

MYSQL* CMySQLMan::GetIdleMySql()
{
MYSQL* pMySql = NULL;
EnterCriticalSection(&m_csList);
if (m_lsIdleList.size() > 0)
{
  pMySql = m_lsIdleList.front();
  m_lsIdleList.pop_front();
  m_lsBusyList.push_back(pMySql);
}
else
{
  pMySql = NULL;
}
LeaveCriticalSection(&m_csList);

return pMySql;
}

void CMySQLMan::SetIdleMysql(MYSQL* pMySql)
{
EnterCriticalSection(&m_csList);
m_lsBusyList.remove(pMySql);
m_lsIdleList.push_back(pMySql);
LeaveCriticalSection(&m_csList);
}

MYSQL_RES* CMySQLMan::SelectRecord(const char *szSql)
{
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return NULL;
}
if(mysql_query(pMySql,szSql))
return NULL;
MYSQL_RES *myquery = NULL;
myquery = mysql_store_result(pMySql);
SetIdleMysql(pMySql);

return myquery;
}

bool CMySQLMan::InsertRecord(const char *szSql)
{
bool bRet = false;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if(mysql_query(pMySql,szSql))
{
bRet = true;
}
SetIdleMysql(pMySql);

return bRet;
}

bool CMySQLMan::UpdateRecord(const char *szSql)
{
bool bRet = false;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if(mysql_query(pMySql,szSql))
{
bRet = true;
}
SetIdleMysql(pMySql);

return bRet;
}

bool CMySQLMan::DelRecord(const char *szSql)
{
bool bRet = false;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if(mysql_query(pMySql,szSql))
{
bRet = true;
}
SetIdleMysql(pMySql);

return bRet;
}

bool CMySQLMan::SelectDB(const char *szDB)
{
bool bRet = false;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
  return false;
}
if (mysql_select_db(pMySql,szDB))
  bRet = false;
else
  bRet = true;
SetIdleMysql(pMySql);

return bRet;
}

my_ulonglong CMySQLMan::GetRowNum(MYSQL_RES *myquery)
{
return mysql_num_rows(myquery);
}

MYSQL_ROW CMySQLMan::GetRecord(MYSQL_RES *myquery)
{
m_row = mysql_fetch_row(myquery);

return m_row;
}

unsigned int CMySQLMan::GetFieldNum(MYSQL_RES *myquery)
{
return mysql_num_fields(myquery);
}

void CMySQLMan::FreeRecord(MYSQL_RES *myquery)
{
mysql_free_result(myquery);
}

//int CMySQLMan::CreateDB(char *db)
//{
// return mysql_create_db(&m_mysql,db);
//}

void CMySQLMan::SeekData(MYSQL_RES *myquery, int offset)
{
mysql_data_seek(myquery,offset);
}

char * CMySQLMan::OutErrors(MYSQL *pMySql)
{
return const_cast(mysql_error(pMySql));
}

BOOL CMySQLMan::IsEnd(MYSQL_RES *myquery)
{
return mysql_eof(myquery);
}

char* CMySQLMan::GetFieldName(MYSQL_RES *myquery, int FieldNum)
{
m_field = mysql_fetch_field_direct(myquery, FieldNum);

return m_field->name;
}

char * CMySQLMan::GetClientInfo()
{
return const_cast(mysql_get_client_info());
}

char* CMySQLMan::GetHostInfo()
{
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return NULL;
}
return const_cast(mysql_get_host_info(pMySql));
}

int CMySQLMan::GetProtocolInfo()
{
int iRet = 0;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return NULL;
}
iRet = mysql_get_proto_info(pMySql);
SetIdleMysql(pMySql);

return iRet;
}

char* CMySQLMan::GetServerInfo()
{
static char szRet[1024];
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return NULL;
}
_tcscpy(szRet, const_cast(mysql_get_server_info(pMySql)));
SetIdleMysql(pMySql);

return szRet;
}

char* CMySQLMan::GetState()
{
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return NULL;
}
static char szRet[1024];
_tcscpy(szRet,const_cast(mysql_stat(pMySql)));
SetIdleMysql(pMySql);

return szRet;
}

bool CMySQLMan::SetCharset()
{
bool bRet = false;
char szSql[50];
strcpy(szSql, "set names gb2312");
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if (mysql_query(pMySql, szSql))
bRet = true;
SetIdleMysql(pMySql);

return bRet;
}

//LOCK TABLES tbl1 READ, tbl2 WRITE
bool CMySQLMan::LockTable(const char *TableName, const char *Priority)
{
bool bRet = false;
char szSql[50];
sprintf(szSql, "LOCK TABLES %s %s", TableName, Priority);
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if (mysql_query(pMySql, szSql))
bRet = true;
SetIdleMysql(pMySql);

return bRet;
}

bool CMySQLMan::UnlockTable()
{
bool bRet = false;
MYSQL *pMySql = GetIdleMySql();
if (pMySql == NULL)
{
return false;
}
if(mysql_query(pMySql,"UNLOCK TABLES"))
bRet = true;
SetIdleMysql(pMySql);

return bRet;

}

�?/a> 2008-02-21 15:10 发表评论

Mon, 18 Feb 2008 03:17:00 GMT

不同的CPU有不同的字节序类�?nbsp;�q�些字节序是指整数在内存中保存的��序 �q�个叫做��L��?nbsp;
最常见的有两种
1�Q?nbsp;Little endian�Q�将低序字节存储在�v始地址
2�Q?nbsp;Big endian�Q�将高序字节存储在�v始地址

LE little-endian
最�W�合人的思维的字节序
地址低位存储值的低位
地址高位存储值的高位
怎么讲是最�W�合人的思维的字节序�Q�是因�ؓ从�h的第一观感来说
低位值小�Q�就应该攑֜�内存地址��的地方�Q�也卛_��存地址低位
反之�Q�高位值就应该攑֜�内存地址大的地方�Q�也卛_��存地址高位

BE big-endian
最直观的字节序
地址低位存储值的高位
地址高位存储值的低位
��Z��么说直观�Q�不要考虑对应关系
只需要把内存地址从左到右按照�׃��到高的顺序写�?nbsp;
把值按照通常的高位到低位的顺序写�?nbsp;
两者对照，一个字节一个字节的填充�q�去

例子�Q�在内存中双�?x01020304(DWORD)的存储方�?nbsp;

内存地址
4000 4001 4002 4003
LE 04 03 02 01
BE 01 02 03 04

例子�Q�如果我们将0x1234abcd写入��C��0x0000开始的内存中，则结果�ؓ
      big-endian  little-endian
0x0000  0x12      0xcd
0x0001  0x23      0xab
0x0002  0xab      0x34
0x0003  0xcd      0x12
x86�p�d��CPU都是little-endian的字节序.

�|�络字节��序是TCP/IP中规定好的一�U�数据表�C�格式，它与具体的CPU�c�d��、操作系�l�等无关�Q�从而可以保证数据在不同��L��之间传输时能够被正确解释。网�l�字节顺序采用big endian排序方式�?br>
��Z��q�行转换 bsd socket提供了�{换的函数有下面四�?br>htons 把unsigned short�c�d��从主机序转换到网�l�序
htonl 把unsigned long�c�d��从主机序转换到网�l�序
ntohs 把unsigned short�c�d��从网�l�序转换��C��机序
ntohl 把unsigned long�c�d��从网�l�序转换��C��机序

在��用little endian的系�l�中 �q�些函数会把字节序进行�{�?nbsp;
在��用big endian�c�d��的系�l�中 �q�些函数会定义成�I�宏

同样在网�l�程序开发时或是跨��^台开发时也应该注意保证只用一�U�字节序不然两方的解释不一样就会��生bug.

注：
1、网�l�与��L��字节转换函数:htons ntohs htonl ntohl (s ��是short l是long h是host n是network)
2、不同的CPU上运行不同的操作�pȝ��Q�字节序也是不同的，参见下表�?br>处理�?nbsp;   操作�pȝ��    字节排序
Alpha    全部    Little endian
HP-PA    NT    Little endian
HP-PA    UNIX    Big endian
Intelx86    全部    Little endian <-----x86�pȝ��是小端字节序�pȝ��
Motorola680x()    全部    Big endian
MIPS    NT    Little endian
MIPS    UNIX    Big endian
PowerPC    NT    Little endian
PowerPC    非NT    Big endian  <-----PPC�pȝ��是大端字节序�pȝ��
RS/6000    UNIX    Big endian
SPARC    UNIX    Big endian
IXP1200 ARM核心    全部    Little endian

下面是一个检验本机字节序的简便方法：

//判断本机的字节序
//�q�回true表�ؓ��段序。返回false表示为大�D�序
bool am_little_endian ()
{
unsigned short i=1;
return (int)*((char *)(&i)) ? true : false;
}
int main()
{
  if(am_little_endian())
{
           printf("本机字节序�ؓ��段�?\n");
}
else
{
          printf("本机字节序�ؓ大段�?\n");
}
        return 0;
}

�?/a> 2008-02-18 11:17 发表评论

Linux�pȝ��环境下的Socket�~�程详细解析

Fri, 18 Jan 2008 01:41:00 GMT

什么是Socket

　　Socket接口�?span>TCP/IP�|�络�?span>API�Q?span>Socket接口定义了许多函数或例程�Q�程序员可以用它们来开�?span>TCP/IP�|�络上的应用�E�序。要�?span>Internet上的TCP/IP�|�络�~�程�Q�必��ȝ��?span>Socket接口�?span>

　　Socket接口设计者最先是��接口放�?span>Unix操作�pȝ��里面的。如果了�?span>Unix�pȝ��的输入和输出的话�Q�就很容易了�?span>Socket了。网�l�的Socket数据传输是一�U�特�D�的I/O�Q?span>Socket也是一�U�文件描�q�符�?span>Socket也具有一个类��g��打开文�g的函数调�?span>Socket()�Q�该函数�q�回一个整型的Socket描述�W�，随后的连接徏立、数据传输等操作都是通过�?span>Socket实现的。常用的Socket�c�d��有两�U�：��式Socket�Q?span>SOCK_STREAM�Q�和数据报式Socket�Q?span>SOCK_DGRAM�Q�。流式是一�U�面向连接的Socket�Q�针对于面向�q�接�?span>TCP服务应用�Q�数据报�?span>Socket是一�U�无�q�接�?span>Socket�Q�对应于无连接的UDP服务应用�?span>

　　Socket建立

　　��Z��建立Socket�Q�程序可以调�?span>socket函数�Q�该函数�q�回一个类��g��文�g描述�W�的句柄�?span>socket函数原型为：

　　int socket(int domain, int type, int protocol);

　　domain指明所使用�?span>协议族，通常�?span>AF_INET�Q�表�C?span>互联�|?/span>协议族（TCP/IP协议族）�Q?span>type参数指定socket的类型：SOCK_STREAM �?span>SOCK_DGRAM�Q?span>Socket接口�q�定义了原始Socket�Q?span>SOCK_RAW�Q�，允许�E�序使用低层协议�Q?span>protocol通常赋�?span>"0"�Q�表�C�根�?span>type来自动选择协议�Q��?span>socket()调用�q�回一个整�?span>socket描述�W�，你可以在后面的调用��用它�?/span>

　　Socket描述�W�是一个指向内部数据结构的指针�Q�它指向描述�W�表入口。调�?span>Socket函数�Ӟ��socket执行体将建立一�?span>Socket�Q�实际上"建立一�?span>Socket"意味着��Z��?span>Socket数据�l�构分配存储�I�间�?span>Socket执行体�ؓ你管理描�q�符表�?/span>

　　两个�|�络�E�序之间的一个网�l�连接包括五�U�信息：通信协议、本地协议地址、本��C��机端口、远端主机地址和远端协议端口�?span>Socket数据�l�构中包含这五种信息�?span>

　　Socket配置

　　通过socket函数调用�q�回一�?span>socket描述�W�后�Q�在使用socket�q�行�|�络传输以前�Q�必��配�|�该socket。面向连接的socket客户端通过调用connect函数�?span>socket数据�l�构中保存本地和�q�端信息。无�q�接socket的客��L��和服务端以及面向�q�接socket的服务端通过调用bind函数来配�|�本��C��息�?span>
bind函数��?span>socket与本��Z��的一个端口相兌��Q�随后你��可以在该端口监听服务请求�?span>bind函数原型为：

int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
sockfd是调�?span>socket函数�q�回�?span>socket描述�W?span>,

my_addr是一个指向包含有本机IP地址及端口号�{�信息的sockaddr�c�d��的指针；

addrlen常被讄��?span>sizeof(struct sockaddr)�?span>
　　struct sockaddr�l�构�c�d��是用来保�?span>socket信息的：
　　struct sockaddr {
　　 unsigned short sa_family; /* 地址族， AF_xxx */
char sa_data[14]; /* 14 字节的协议地址 */
};
　　sa_family一般�ؓAF_INET�Q�代�?span>Internet�Q?span>TCP/IP�Q�地址族；sa_data
则包含该socket�?span>IP地址和端口号�?span>
　　另外�q�有一�U�结构类型：
　　struct sockaddr_in {
　　 short int sin_family; /* 地址�?span> */
　　 unsigned short int sin_port; /* 端口�?span> */
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */
　　};

　　�q�个�l�构更方便��用�?span>sin_zero用来��?span>sockaddr_in�l�构填充��C��struct sockaddr同样的长度，可以�?span>bzero()�?span>memset()函数��其�|��ؓ零。指�?span>sockaddr_in 的指针和指向sockaddr的指针可以相互�{换，�q�意味着如果一个函数所需参数�c�d��?span>sockaddr�Ӟ��你可以在函数调用的时候将一个指�?span>sockaddr_in的指针�{换�ؓ指向sockaddr的指针；或者相反�?span>

　　使用bind函数�Ӟ��可以用下面的赋值实现自动获得本�?span>IP地址和随��取一个没有被占用的端口号�Q?span>

　　my_addr.sin_port = 0; /* �pȝ��随机选择一个未被��用的端口�?span> */
　　my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
通过��?span>my_addr.sin_port�|��ؓ0�Q�函��C��自动��Z��选择一个未占用的端口来使用。同��P��通过��?span>my_addr.sin_addr.s_addr�|��ؓINADDR_ANY�Q�系�l�会自动填入本机IP地址�?/span>

　　注意在��?span>bind函数是需要将sin_port�?span>sin_addr转换成�ؓ�|�络字节优先��序�Q��?span>sin_family则不需要�{换�?/span>

　　计算机数�?span>存储有两�U�字节优先顺序：高位字节优先和低位字节优先�?span>Internet上数据以高位字节优先��序在网�l�上传输�Q�所以对于在内部是以低位字节优先方式存储数据的机器，�?span>Internet上传输数据时��需要进行�{换，否则��׃��出现数据不一致�?/span>

　　下面是几个字节顺序�{换函敎ͼ�

·htonl()�Q�把32位��g��L��字节序�{换成�|�络字节�?span>
·htons()�Q�把16位��g��L��字节序�{换成�|�络字节�?span>
·ntohl()�Q�把32位��g��|�络字节序�{换成��L��字节�?span>
·ntohs()�Q�把16位��g��|�络字节序�{换成��L��字节�?span>

　　bind()函数在成功被调用时返�?span>0�Q�出现错误时�q�回"-1"�q�将errno�|��ؓ相应的错误号。需要注意的是，在调�?span>bind函数时一般不要将端口��L��为小�?span>1024的��|��因�ؓ1�?span>1024是保留端口号�Q�你可以选择大于1024中的��M��一个没有被占用的端口号�?/span>

�q�接建立

面向�q�接的客��L��序��?span>connect函数来配�|?span>socket�q�与�q�端服务�?/span>建立一�?span>TCP�q�接�Q�其函数原型为：

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
sockfd�?span>socket函数�q�回�?span>socket描述�W�；serv_addr是包含远端主�?span>IP地址和端口的指针�Q?span>addrlen是远端地址�l�构的长�?span>(sizeof(struct sockaddr))�?span>connect函数在出现错误时�q�回-1�Q��ƈ且设�|?span>errno为相应的错误码。进行客��L��E�序设计无须调用bind()�Q�因��U�情况下只需知道目的机器�?span>IP地址�Q�而客户通过哪个端口�?span>服务�?/span>建立�q�接�q�不需要关心，socket执行体�ؓ你的�E�序自动选择一个未被占用的端口�Q��ƈ通知你的�E�序数据什么时候到打断口�?/span>

　　connect函数启动和远端主机的直接�q�接。只有面向连接的客户�E�序使用socket时才需要将�?span>socket与远端主机相�q�。无�q�接协议从不建立直接�q�接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客��L��h��?span>

　　listen函数�?span>socket处于被动的监听模式，�q��ؓ�?span>socket建立一个输入数据队列，��到辄��服务��h��保存在此队列中，直到�E�序处理它们�?/span>

　　int listen(int sockfd�Q?span> int backlog);

　　sockfd�?span>Socket�pȝ��调用�q�回�?span>socket 描述�W�；backlog指定在请求队列中允许的最大请求数�Q�进入的�q�接��h��在队列中等�?span>accept()它们�Q�参考下文）�?span>backlog寚w��列中�{�待服务的请求的数目�q�行了限�Ӟ��大多数系�l�缺省��gؓ20。如果一个服务请求到来时�Q�输入队列已满，�?span>socket��拒�l�连接请求，客户��收��C��个出错信息�?/span>

　　当出现错误时listen函数�q�回-1�Q��ƈ�|�相应的errno错误码�?/span>

　　accept()函数让服务器接收客户的连接请求。在建立好输入队列后�Q�服务器��p��?span>accept函数�Q�然后睡眠�ƈ�{�待客户的连接请求�?/span>

　　int accept(int sockfd, void *addr, int *addrlen);

　　sockfd是被监听�?span>socket描述�W�，addr通常是一个指�?span>sockaddr_in变量的指针，该变量用来存放提��接请求服务的��L��的信息（某台��L��从某个端口发��h��Q�；addrlen通常��Z��个指向��gؓsizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数�q�回-1�q�置相应�?span>errno倹{�?/span>

　　首先�Q�当accept函数监视�?span>socket收到�q�接��h��Ӟ��socket执行体将建立一个新�?span>socket�Q�执行体��这个新socket和请求连接进�E�的地址联系��h��Q�收到服务请求的初始socket仍可以��l�在以前�?span> socket上监听，同时可以在新�?span>socket描述�W�上�q�行数据传输操作�?span>

　　数据传输

　　send()�?span>recv()�q�两个函数用于面向连接的socket上进行数据传输�?span>

　　send()函数原型为：

　　int send(int sockfd, const void *msg, int len, int flags);
sockfd是你想用来传输数据的socket描述�W�；msg是一个指向要发送数据的指针�Q?span>len是以字节为单位的数据的长度；flags一般情况下�|��ؓ0�Q�关于该参数的用法可参照man手册�Q��?span>

　　send()函数�q�回实际上发送出的字节数�Q�可能会��于你希望发送的数据。在�E�序中应该将send()的返回��g��Ʋ发送的字节数进行比较。当send()�q�回��g��len不匹配时�Q�应该对�q�种情况�q�行处理�?span>
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描述�W�；buf 是存放接收数据的�~�冲区；len是缓冲的长度�?span>Flags也被�|��ؓ0�?span>recv()�q�回实际上接收的字节敎ͼ�当出现错误时�Q�返�?span>-1�q�置相应�?span>errno倹{�?span>

　　sendto()�?span>recvfrom()用于在无�q�接的数据报socket方式下进行数据传输。由于本�?span>socket�q�没有与�q�端机器建立�q�接�Q�所以在发送数据时应指明目的地址�?span>
　　sendto()函数原型为：
　　int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);

　　该函数比send()函数多了两个参数�Q?span>to表示目地机的IP地址和端口号信息�Q��?span>tolen常常被赋��gؓsizeof (struct sockaddr)�?span>sendto 函数也返回实际发送的数据字节长度或在出现发送错误时�q�回-1�?span>

　　recvfrom()函数原型为：

　　int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);

　　from是一�?span>struct sockaddr�c�d��的变量，该变量保存源机的IP地址及端口号�?span>fromlen常置�?span>sizeof (struct sockaddr)。当recvfrom()�q�回�Ӟ��fromlen包含实际存入from中的数据字节数�?span>recvfrom()函数�q�回接收到的字节数或当出现错误时�q�回-1�Q��ƈ�|�相应的errno�?span>

　　如果你对数据�?span>socket调用�?span>connect()函数�Ӟ��你也可以利用send()�?span>recv()�q�行数据传输�Q�但�?span>socket仍然是数据报socket�Q��ƈ且利用传输层�?span>UDP服务。但在发送或接收数据报时�Q�内�怼�自动��Z��加上目地和源地址信息�?span>

　　�l�束传输

　　当所有的数据操作�l�束以后�Q�你可以调用close()函数来释放该socket�Q�从而停止在�?span>socket上的��M��数据操作�Q?span>

　　close(sockfd);

　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输��l�进行。如你可以关闭某socket的写操作而允许��l�在�?span>socket上接受数据，直至��d��所有数据�?span>

　　int shutdown(int sockfd,int how);

　　sockfd是需要关闭的socket的描�q�符。参�?span> how允许�?span>shutdown操作选择以下几种方式�Q?span>
·0-------不允许��l�接收数�?span>
·1-------不允许��l�发送数�?span>
·2-------不允许��l�发送和接收数据�Q?span>
·均�ؓ不允许则调用close()

　　shutdown在操作成功时�q�回0�Q�在出现错误时返�?span>-1�q�置相应errno�?span>

面向�q�接�?span>Socket实例

　　代码实例中的服务器通过socket�q�接向客��L��发送字�W�串"Hello, you are connected!"。只要在服务器上�q�行该服务器软�g�Q�在客户端运行客戯��Y�Ӟ��客户端就会收到该字符丌Ӏ?span>

　　该服务器软�g代码如下�Q?span>

#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 3333 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{
int sockfd,client_fd; /*sock_fd�Q�监�?span>socket�Q?span>client_fd�Q�数据传�?span>socket */
　struct sockaddr_in my_addr; /* 本机地址信息 */
　struct sockaddr_in remote_addr; /* 客户端地址信息 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
　　perror("socket创徏出错�Q?span>"); 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出错�Q?span>");
exit(1);
}
　if (listen(sockfd, BACKLOG) == -1) {
perror("listen出错�Q?span>");
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()) { /* 子进�E�代码段 */
　　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 perror("send出错�Q?span>");
close(client_fd);
exit(0);
}
　　close(client_fd);
　　}
　}
}

　　服务器的工作��程是这��L��Q�首先调�?span>socket函数创徏一�?span>Socket�Q�然后调�?span>bind函数��其与本机地址以及一个本地端口号�l�定�Q�然后调�?span>listen在相应的socket上监听，�?span>accpet接收��C��个连接服务请求时�Q�将生成一个新�?span>socket。服务器昄��该客��h��?span>IP地址�Q��ƈ通过新的socket向客��L��发送字�W�串"Hello�Q?span>you are connected!"。最后关闭该socket�?/span>

　　代码实例中的fork()函数生成一个子�q�程来处理数据传输部分，fork()语句对于子进�E�返回的��gؓ0。所以包�?span>fork函数�?span>if语句是子�q�程代码部分�Q�它�?span>if语句后面的父�q�程代码部分是�ƈ发执行的�?span>

　　客户端程序代码如下：

#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 3333
#define MAXDATASIZE 100 /*每次最大数据传输量 */
main(int argc, char *argv[]){
　int sockfd, recvbytes;
　char buf[MAXDATASIZE];
　struct hostent *host;
　struct sockaddr_in serv_addr;
　if (argc < 2) {
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
　if((host=gethostbyname(argv[1]))==NULL) {
herror("gethostbyname出错�Q?span>");
exit(1);
}
　if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket创徏出错�Q?span>");
exit(1);
}
　serv_addr.sin_family=AF_INET;
　serv_addr.sin_port=htons(SERVPORT);
　serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
　bzero(&(serv_addr.sin_zero),8);
　if (connect(sockfd, (struct sockaddr *)&serv_addr, \
　　 sizeof(struct sockaddr)) == -1) {
perror("connect出错�Q?span>");
exit(1);
}
　if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) {
perror("recv出错�Q?span>");
exit(1);
}
　buf[recvbytes] = '\0';
　printf("Received: %s",buf);
　close(sockfd);
}

客户端程序首先通过服务器域名获得服务器�?span>IP地址�Q�然后创��Z��?span>socket�Q�调�?span>connect函数与服务器建立�q�接�Q�连接成功之后接收从服务器发送过来的数据�Q�最后关�?span>socket�?/span>

　　函数gethostbyname()是完成域名�{换的。由�?span>IP地址难以记忆和读写，所以�ؓ了方便，��Z��常常用域名来表示��L��Q�这��需要进行域名和IP地址的�{换。函数原型�ؓ�Q?/span>

　　struct hostent *gethostbyname(const char *name);
　　函数�q�回�?span>hosten的结构类型，它的定义如下�Q?span>
　　struct hostent {
　 char *h_name; /* ��L��的官方域�?span> */
　　 char **h_aliases; /* 一个以NULL�l�尾的主机别名数�l?span> */
　　 int h_addrtype; /* �q�回的地址�c�d��Q�在Internet环境下�ؓAF-INET */
　　int h_length; /* 地址的字节长�?span> */
　　 char **h_addr_list; /* 一个以0�l�尾的数�l�，包含该主机的所有地址*/
　　};
　　#define h_addr h_addr_list[0] /*�?span>h-addr-list中的�W�一个地址*/

　　�?span> gethostname()调用成功�Ӟ��q�回指向struct hosten的指针，当调用失败时�q�回-1。当调用gethostbyname�Ӟ��你不能��?span>perror()函数来输出错误信息，而应该��?span>herror()函数来输出�?span>

　　无连接的客户/服务器程序的在原理上和连接的客户/服务器是一��L��Q�两者的区别在于无连接的客户/服务器中的客户一般不需要徏立连接，而且在发送接收数据时�Q�需要指定远端机的地址�?span>

　　��d��和非��d��

　　��d��函数在完成其指定的�Q务以前不允许�E�序调用另一个函数。例如，�E�序执行一个读数据的函数调用时�Q�在此函数完成读操作以前��不会执行下一�E�序语句。当服务器运行到accept语句�Ӟ��而没有客戯��接服务请求到来，服务器就会停止在accept语句上等待连接服务请求的到来。这�U�情�늧�为阻塞（blocking�Q�。而非��d��操作则可以立卛_��成。比如，如果你希望服务器仅仅注意��查是否有客户在等待连接，有就接受�q�接�Q�否则就�l�箋做其他事情，则可以通过��?span>Socket讄��为非��d��方式来实现。非��d��socket在没有客户在�{�待时就�?span>accept调用立即�q�回�?span>
　　#include
　　#include
　　……
sockfd = socket(AF_INET,SOCK_STREAM,0);
fcntl(sockfd,F_SETFL,O_NONBLOCK)�Q?span>
……

　　通过讄��socket为非��d��方式�Q�可以实�?span>"轮询"若干Socket。当企图从一个没有数据等待处理的非阻�?span>Socket��d��数据�Ӟ��函数��立卌��回，�q�回��gؓ-1�Q��ƈ�|?span>errno��gؓEWOULDBLOCK。但是这�U?span>"轮询"会��CPU处于忙等待方式，从而降低性能�Q�浪费系�l�资源。而调�?span>select()会有效地解决�q�个问题�Q�它允许你把�q�程本��n挂�v来，而同时�ɾpȝ��内核监听所要求的一�l�文件描�q�符的�Q何活动，只要��认在�Q何被监控的文件描�q�符上出现活动，select()调用��返回指�C��文�g描述�W�已准备好的信息�Q�从而实��C��E�选出随机的变化，而不必由�q�程本��n对输入进行测试而浪�?span>CPU开销�?span>select函数原型�?span>:
int select(int numfds,fd_set *readfds,fd_set *writefds�Q?span>
fd_set *exceptfds,struct timeval *timeout);

　　其中readfds�?span>writefds�?span>exceptfds分别是被select()监视的读、写和异常处理的文�g描述�W�集合。如果你希望��定是否可以从标准输入和某个socket描述�W�读取数据，你只需要将标准输入的文件描�q�符0和相应的sockdtfd加入�?span>readfds集合中；numfds的值是需要检查的��L��最高的文�g描述�W�加1�Q�这个例子中numfds的值应�?span>sockfd+1�Q�当select�q�回�Ӟ��readfds��被修改�Q�指�C�某个文件描�q�符已经准备被读取，你可以通过FD_ISSSET()来测试。�ؓ了实�?span>fd_set中对应的文�g描述�W�的讄��、复位和��试�Q�它提供了一�l�宏�Q?span>
　　FD_ZERO(fd_set *set)----清除一个文件描�q�符集；
　　FD_SET(int fd,fd_set *set)----��一个文件描�q�符加入文�g描述�W�集中；
　　FD_CLR(int fd,fd_set *set)----��一个文件描�q�符从文件描�q�符集中清除�Q?span>
　　FD_ISSET(int fd,fd_set *set)----试判断是否文件描�q�符被置位�?span>
　　Timeout参数是一个指�?span>struct timeval�c�d��的指针，它可以��select()在等�?span>timeout长时间后没有文�g描述�W�准备好卌��回�?span>struct timeval数据�l�构为：
　　struct timeval {
　　 int tv_sec; /* seconds */
　　 int tv_usec; /* microseconds */ };

　　POP3客户端实�?span>

　　下面的代码实例基�?span>POP3的客户协议，与邮件服务器�q�接�q�取回指定用户帐��L��邮�g。与邮�g服务器交互的命��o存储在字�W�串数组POPMessage中，�E�序通过一�?span>do-while循环依次发送这些命令�?span>

#include
#include
#include
#include
#include
#include
#include
#include
#define POP3SERVPORT 110
#define MAXDATASIZE 4096

main(int argc, char *argv[]){
int sockfd;
struct hostent *host;
struct sockaddr_in serv_addr;
char *POPMessage[]={
"USER userid\r\n",
"PASS password\r\n",
"STAT\r\n",
"LIST\r\n",
"RETR 1\r\n",
"DELE 1\r\n",
"QUIT\r\n",
NULL
};
int iLength;
int iMsg=0;
int iEnd=0;
char buf[MAXDATASIZE];

if((host=gethostbyname("your.server"))==NULL) {
perror("gethostbyname error");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket error");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(POP3SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1){
perror("connect error");
exit(1);
}

do {
send(sockfd,POPMessage[iMsg],strlen(POPMessage[iMsg]),0);
printf("have sent: %s",POPMessage[iMsg]);

iLength=recv(sockfd,buf+iEnd,sizeof(buf)-iEnd,0);
iEnd+=iLength;
buf[iEnd]='\0';
printf("received: %s,%d\n",buf,iMsg);

iMsg++;
} while (POPMessage[iMsg]);

close(sockfd);
}

�?/a> 2008-01-18 09:41 发表评论

Wed, 05 Dec 2007 07:58:00 GMT

输入是点分的IP地址格式�Q�如A.B.C.D)的字�W�串�Q�从该字�W�串中提取出每一部分�Q��{换�ؓULONG,假设得到4个ULONG型的A,B,C,D,
ulAddress�Q�ULONG型）是�{换后的结果，
ulAddress = D<<24 + C<<16 + B<<8 + A(�|�络字节序）�Q�即inet_addr(const char *)的返回结�?br>另外�Q�我们也可以得到把该IP转换��Z��机序的结果，转换�Ҏ��一�?br>A<<24 + B<<16 + C<<8 + D

�?/a> 2007-12-05 15:58 发表评论