c语言tcp
1. 怎样用c语言或者c++实现tcp，并实现文本传输
TCP协议实现文件传输
使用TCP协议实现传输文件
程序分为发送端和接收端。首先在传输文件数据之前，发送端会把将装有文件名称和文件长度等
信息的数据包发送至接收端。接收端收到文件名称和文件长度信息后会创建好空白文件。接着开始传输
文件数据。下面介绍实现功能的主要过程：
1.创建套接字、绑定、监听、连接、接受连接
//创建TCP协议的套接字
m_Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(SOCKET_ERROR == m_Socket)
AfxMessageBox("Create Socket Error! ", 0, 0);
//绑定与监听
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.s_addr = inet_addr(sIP);
addrSrv.sin_family = AF_INET;
addrSrv.sin_port = htons(Port);
int ret = bind(m_Socket, (SOCKADDR *)&addrSrv, sizeof(SOCKADDR));
if(ret==SOCKET_ERROR)
AfxMessageBox("Bind Socket Error!", 0, 0);
//连接
SOCKADDR_IN ServerAddr;
ServerAddr.sin_addr.s_addr = inet_addr(ServerAddr_in);
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons(ServerPort);
int Result = connect(m_Socket, (struct sockaddr*)&ServerAddr, sizeof(struct sockaddr));
if(SOCKET_ERROR == Result)
AfxMessageBox("Connet Failed!");
//接受连接
SOCKADDR_IN ClientAddr;
int len = sizeof(SOCKADDR_IN);
SOCKET ClientSock = accept(m_Socket, (struct sockaddr*)&ClientAddr, &len);
if(SOCKET_ERROR == ClientSock)
AfxMessageBox("Accept Failed!");
2.声明宏和结构体
声明套接字缓冲区和一次发送文件数据的缓冲区大小
#define SOCKET_BUFF 80000 //套接字缓冲区大小
#define PACK_BUFF 50000 //数据包缓冲区大小
声明文件I/O缓冲区和最大文件路径长度
#define FILE_NAME_MAX 100 //文件路径最大长度
#define FILE_IO_BUFF PACK_BUFF //文件IO缓冲区
//文件信息
typedef struct _FileInfor
{
u_long ulFileLen;
char sFileName[ FILE_NAME_MAX ];
}_FileInfor;
//数据包
typedef struct _DataPack
{
char cType; //'D'为数据 'M'为文件信息
int nPackLen;
char sContent[ PACK_BUFF ]; //数据包缓冲区
u_long nPosition; //数据在文件中的位置
int nContentLen; //数据字节数
_FileInfor FileInfor; //文件信息
}_DataPack;
3.发送端
//发送线程需要的全局变量
char sPath[FILE_NAME_MAX]; //文件地址
u_long FileByteCount; //文件大小
SOCKET ClientSocket; //
(1)设置套接字发送缓冲区大小，在32位Windows XP环境下，系统为每个套接字分配的默认发送数据缓
冲区为8192字节。由于传输的文件很大，可能几十兆，或者更大。那么系统为每个套接字分配的默认
缓冲区显然过小。为此在创建套接字之后，需要修改套接字发送数据缓冲尺寸。在这里我修改为80k，
差不多可以够用了。
//设置套接字发送缓冲区
int nBuf = SOCKET_BUFF;
int nBufLen = sizeof(nBuf);
int nRe = setsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, nBufLen);
if(SOCKET_ERROR == nRe)
AfxMessageBox("setsockopt error!");
//检查缓冲区是否设置成功
nRe = getsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, &nBufLen);
if(SOCKET_BUFF != nBuf)
AfxMessageBox("检查缓冲区:setsockopt error!");
(2)测量文件大小并发送文件大小和名称给客户端
首先使用C库函数对源文件进行测量
//得到文件地址
LPTSTR lpPath = m_sPath.GetBuffer( m_sPath.GetLength ());
//打开文件
FILE *File = fopen(lpPath, "rb");
if(NULL == File)
AfxMessageBox("打开文件失败!");
//测量文件大小
char Buff[PACK_BUFF];
u_long ulFaceReadByte;
FileByteCount = 0;
fseek(File, 0, SEEK_SET);
while(!feof(File))
{
ulFaceReadByte = fread(Buff, 1, 1, File);
FileByteCount += ulFaceReadByte;
}
//关闭文件
int nRe = fclose(File);
if(nRe)
AfxMessageBox("关闭文件失败!");
此时以获取源文件的长度，我们将文件长度和文件名称放到数据包中，设置数据包为'M'类型。
//打包
_DataPack Pack;
Pack.cType = 'M';
Pack.nPackLen = sizeof(Pack);
//取得文件名
ZeroMemory(Pack.FileInfor.sFileName, FILE_NAME_MAX);
GetFIieNameFromPath(lpPath, Pack.FileInfor.sFileName);
Pack.FileInfor.ulFileLen = FileByteCount;
接着使用send()将打包完成的数据包发送给接收端,把发送线程的全局变量初始化，并创建发送线
程，文件数据将由发送线程负责发送
//发送数据包 文件大小和名称
nRe = send(m_ClientSockFd.fd_array[0], (char*)&Pack, Pack.nPackLen, 0);
if(SOCKET_ERROR == nRe)
AfxMessageBox("Send File Size Failed!");
//线程准备全局变量
strcpy(sPath, m_sPath);
ClientSocket = m_ClientSockFd.fd_array[0];
//启动线程发送文件
DWORD ID;
m_hSendThread = CreateThread(0, 0, SendDataThrad, 0, 0, &ID);
(3)发送文件数据线程。先打开源文件，为了一次读取大量数据将文件缓冲区设置为FILE_IO_BUFF大小，
然后将读取的数据打包并发送。这样不断地读、不断地发送，直到将整个文件发送完为止。
DWORD __stdcall CServerDlg::SendDataThrad(LPVOID LpP)
{
//打开文件
FILE *File = fopen(sPath, "rb");
if(NULL == File)
{
AfxMessageBox("SendDataThrad中打开文件失败!");
return 1;
}
//设置文件缓冲区
int nBuff = FILE_IO_BUFF;
if(setvbuf(File, (char*)&nBuff, _IOFBF, sizeof(nBuff)))
AfxMessageBox("设置文件缓冲区失败!");
//读取文件数据并发送
u_long ulFlagCount = 0; //记录读了多少数据
u_long FaceReadByte = 0; //一次实际读取的字节数
char sBuff[PACK_BUFF];
ZeroMemory(sBuff, PACK_BUFF);
fseek(File, 0, SEEK_SET);
while (!feof(File))
{
FaceReadByte = fread(sBuff, 1, PACK_BUFF, File);
//打包
_DataPack DataPack;
DataPack.cType = 'D';
DataPack.nPackLen = sizeof(DataPack);
DataPack.nContentLen = FaceReadByte;
CopyMemory(DataPack.sContent, sBuff, FaceReadByte);
DataPack.nPosition = ulFlagCount;
//发送
int nResult = send(ClientSocket, (char*)&DataPack, DataPack.nPackLen, 0);
if (SOCKET_ERROR == nResult)
{
AfxMessageBox("SendDataThrad中发送数据失败!");
}else
ulFlagCount += FaceReadByte; //记录发送字节数
}
AfxMessageBox("发送结束");
//关闭
int nRe = fclose(File);
if(nRe)
AfxMessageBox("SendDataThrad中关闭文件失败!");
return 0;
}
4.接收端
//接收线程用的全局变量
_FileInfor FileInfor; //文件信息
u_long ulWriteByte; //记录总共写入的字节
char lpPath[FILE_NAME_MAX]; //文件路径
char sFilePathAndName[FILE_NAME_MAX]; //完整的文件路径
(1)设置套接字接收缓冲区大小。
//设置套接字接收缓冲区
int nBuf = SOCKET_BUFF;
int nBufLen = sizeof(nBuf);
SOCKET ClientSock = m_Sock.GetSocket();
int nRe = setsockopt(ClientSock, SOL_SOCKET, SO_RCVBUF, (char*)&nBuf, nBufLen);
if(SOCKET_ERROR == nRe)
AfxMessageBox("setsockopt error!");
//检查缓冲区是否设置成功
nRe = getsockopt(ClientSock, SOL_SOCKET, SO_RCVBUF, (char*)&nBuf, &nBufLen);
if(SOCKET_BUFF != nBuf)
AfxMessageBox("检查缓冲区:setsockopt error!");
(2)接收文件信息和文件数据线程。先判断数据包是属于文件信息还是文件类型，如果是文件信息就根
据信息创建空文件，如果是文件数据就将数据已追加的方式写进目的文件中。
DWORD __stdcall CClientDlg::ReceiveDataPro(LPVOID LpP)
{
CSocket_Win32 *pCSock = (CSocket_Win32*)LpP;
u_long ulWriteByteCount = 0;
while (1)
{
_DataPack DataPack;
ZeroMemory(&DataPack, sizeof(DataPack));
if(!(*pCSock).Receive(&DataPack, sizeof(DataPack)))
{
AfxMessageBox("Receive DataPack Failed!");
}
//判断数据包类型
if('M' == DataPack.cType) //包为文件信息
{
//接收文件信息
FileInfor.ulFileLen = DataPack.FileInfor.ulFileLen; //获取文件长度
strcpy(FileInfor.sFileName, DataPack.FileInfor.sFileName); //获取文件名称
//得到文件目录
char sFilePath[FILE_NAME_MAX];
ZeroMemory(sFilePath, FILE_NAME_MAX);
strcpy(sFilePath, lpPath);
strcat(sFilePath, FileInfor.sFileName);
strcat(sFilePathAndName, sFilePath); //保存完整的文件路径
//创建文件
SECURITY_ATTRIBUTES attr;
attr.nLength = FileInfor.ulFileLen;
attr.lpSecurityDescriptor = NULL;
HANDLE hRe = CreateFile(sFilePath, GENERIC_WRITE, FILE_SHARE_WRITE, &attr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if(INVALID_HANDLE_VALUE == hRe)
AfxMessageBox("创建文件失败!");
bool bRe = ::CloseHandle(hRe);
//可以开始接受文件
bIsStartReceive = true;
}else if('D' == DataPack.cType) //包为文件数据
{
//打开文件
char sPath[FILE_NAME_MAX];
strcpy(sPath, sFilePathAndName);
FILE *File = fopen(sPath, "ab");
if(0 == File)
AfxMessageBox("打开文件失败!");
//设置文件缓冲区
int nBuff = FILE_IO_BUFF;
if(setvbuf(File, (char*)&nBuff, _IOFBF, sizeof(nBuff)))
AfxMessageBox("设置文件缓冲区失败!");
//定位文件
u_long nPosition = DataPack.nPosition;
int nRe = fseek(File, nPosition, SEEK_SET);
if(nRe)
AfxMessageBox("SendDataThrad中定位失败!");
//写文件
u_long nNumberOfBytesWritten = fwrite(&DataPack.sContent, 1, DataPack.nContentLen, File);
if(DataPack.nContentLen != nNumberOfBytesWritten)
AfxMessageBox("写文件失败!");
else
{
ulWriteByteCount += nNumberOfBytesWritten;
}
fflush(File); //清除文件缓冲区
//关闭文件
nRe = fclose(File);
if(nRe)
AfxMessageBox("关闭文件失败!");
if(ulWriteByteCount >= FileInfor.ulFileLen)
{
AfxMessageBox("接收结束");
break;
}
}
}
return 0;
}
2. C语言 TCP Client消息接收问题
你说的传递出去是传递给主线程吗，如果是的话那就很简单，因为同一个进程的线程之间共享一个堆栈的，你只需要定义一个全局变量，主线程和子线程都能访问到。但是这样你就需要注意访问这个全局变量的时候的访问冲突问题，一般这种问题是通过互斥锁解决的，也就是在访问全局变量之前先加锁，访问完了释放锁。
3. 在linux系统中用c语言编写一个网络tcp主从通信的socket程序，要求发送数据包
没有你想象的那么复杂，其实监听端口，然后read或者write就够了。
4. C语言编写TCP的文件传输
粗略看了一下,你是用户的是TCP不是UDP,注意一点TCP可靠安全但是需要你自己手动处理粘包问题.你要是想学网络编程,就需要学会分析和定制协议.我建议你先去看看TFTP的网络协议.所谓的通信就是我发请求给你,你给我应答(请求成功还是失败).你刚学网络编程,直接是使用tcp不是很合适,你可以去看看TFTP的协议(向服务器请求下载或者上传文件).复杂一点的程序一搬都需要定制网络协议,tcp则还需要处理粘包问题.如果你想学,可以和我联系,我可以发你资料→_→
5. C语言实现socket编程TCP通信的问题
我做试验，发现是如果你这样写：
char sendbuf[1024] = {"123456\n"};
也就是发送数据加上了换行，服务端立即显示了。看来不加换行就被缓存了（应该是被服务端收到但缓存了）。
6. 求一个C语言的TCP 客户/服务 连接示例代码
#include <stdio.h>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
void main() {
// 初始化
WSADATA wsaData;
int iResult = WSAStartup( MAKEWORD(2,2), &wsaData );
if ( iResult != NO_ERROR )
printf("Error at WSAStartup()\n");
// 建立socket
SOCKET server;
server = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
if ( server == INVALID_SOCKET ) {
printf( "Error at socket(): %ld\n", WSAGetLastError() );
WSACleanup();
return;
}
// 绑定socket
sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr( "127.0.0.1" );
service.sin_port = htons( 27015 );
if ( bind( server, (SOCKADDR*) &service, sizeof(service) ) == SOCKET_ERROR ) {
printf( "bind() failed.\n" );
closesocket(server);
return;
}
// 监听 socket
if ( listen( server, 1 ) == SOCKET_ERROR )
printf( "Error listening on socket.\n");
// 接受连接
SOCKET AcceptSocket;
printf( "Waiting for a client to connect...\n" );
while (1) {
AcceptSocket = SOCKET_ERROR;
while ( AcceptSocket == SOCKET_ERROR ) {
AcceptSocket = accept( server, NULL, NULL );
}
printf( "Client Connected.\n");
server = AcceptSocket;
break;
}
// 发送接受数据
int bytesSent;
int bytesRecv = SOCKET_ERROR;
char sendbuf[32] = "Server: Sending Data.";
char recvbuf[32] = "";
bytesRecv = recv( server, recvbuf, 32, 0 );
printf( "Bytes Recv: %ld\n", bytesRecv );
bytesSent = send( server, sendbuf, strlen(sendbuf), 0 );
printf( "Bytes Sent: %ld\n", bytesSent );
return;
}
SERVER的
7. 用c语言写个 socket tcp 的
#include <winsock2.h>
#include <stdio.h>
#include <pthread.h>
#pragma comment(lib,"ws2_32.lib")
typedef struct{
SOCKET accpt;
int lock;
}Arg;
void *transfer(void *arg)
{
Arg * info = (Arg *)arg;
SOCKET clientSock;
char recvbuf[102];
char sendBuf[] = "10";
int ret;
memcpy(&clientSock,(void*)&info->accpt,sizeof(clientSock));
info->lock =1;
while (TRUE)
{
ret = send(clientSock,sendBuf,2,0);
if (ret == -1)
{
break;
}
ret = recv(clientSock,recvbuf,102,0);
printf("%s ",recvbuf);
}
return (void *)0;
}
void* timer(void *arg)
{
time_t last = time(NULL);
time_t now;
int i = 20;
while(i--)
{
now = time(NULL);
if(now - last == 1)
{
printf("1s past! ");
last = now;
}
Sleep(500);
}
printf("timer exit. ");
return (void *)0;
}
int main(void) {
WSADATA wsaData;
SOCKET ListenSocket;
SOCKADDR_IN service,client;
int len = sizeof(client);
Arg argument;
pthread_t tid;
char sendBuf[] = "ID=2;WHAT=host";
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != NO_ERROR) {
printf("Error at WSAStartup() ");
return 1;
}
ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld ", WSAGetLastError());
WSACleanup();
return 1;
}
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");
service.sin_port = htons(27115);
if (bind( ListenSocket,
(SOCKADDR*) &service,
sizeof(service)) == SOCKET_ERROR) {
printf("bind() failed. ");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
printf("Error listening on socket. ");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
argument.lock = 1;
printf("Waiting for client to connect... ");
pthread_create(&tid,NULL,timer,NULL);
while(TRUE){
argument.accpt = accept( ListenSocket, (SOCKADDR*)&client, &len );
if (argument.accpt == INVALID_SOCKET) {
printf("accept failed: %d ", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
} else {
printf("accept%s:%d ",inet_ntoa(client.sin_addr),client.sin_port);
while (!argument.lock);
argument.lock = 0;
// sendto(argument.accpt,sendBuf,sizeof(sendBuf),0,(SOCKADDR*)&client,len);
pthread_create(&tid,NULL,transfer,&argument);
//send(AcceptSocket,sendBuf,sizeof(sendBuf),0);
}
}
// No longer need server socket
closesocket(ListenSocket);
WSACleanup();
return 0;
}
发送数据格式按需求。可以发送字符串，也可以发送结构体。如果发送结构体的话，要注意序列化和反序列化。程序例子是服务器对每个客户端的connect动作起一个线程去交互。还有一个线程是定时器。
8. Windows系统用C语言写TCP通信
#include
#include
#include
#pragma comment(lib,"ws2_32.lib")
typedef struct{
SOCKET accpt;
int lock;
}Arg;
void *transfer(void *arg)
{
Arg * info = (Arg *)arg;
SOCKET clientSock;
char recvbuf[102];
char sendBuf[] = "10";
int ret;
memcpy(&clientSock,(void*)&info->accpt,sizeof(clientSock));
info->lock =1;
while (TRUE)
{
ret = send(clientSock,sendBuf,2,0);
if (ret == -1)
{
break;
}
ret = recv(clientSock,recvbuf,102,0);
printf("%s\n",recvbuf);
}
return (void *)0;
}
void* timer(void *arg)
{
time_t last = time(NULL);
time_t now;
int i = 20;
while(i--)
{
now = time(NULL);
if(now - last == 1)
{
printf("1s past!\n");
last = now;
}
Sleep(500);
}
printf("timer exit.\n");
return (void *)0;
}
int main(void) {
WSADATA wsaData;
SOCKET ListenSocket;
SOCKADDR_IN service,client;
int len = sizeof(client);
Arg argument;
pthread_t tid;
char sendBuf[] = "ID=2;WHAT=host";
int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
if (iResult != NO_ERROR) {
printf("Error at WSAStartup()\n");
return 1;
}
ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ListenSocket == INVALID_SOCKET) {
printf("Error at socket(): %ld\n", WSAGetLastError());
WSACleanup();
return 1;
}
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1");
service.sin_port = htons(27115);
if (bind( ListenSocket,
(SOCKADDR*) &service,
sizeof(service)) == SOCKET_ERROR) {
printf("bind() failed.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
printf("Error listening on socket.\n");
closesocket(ListenSocket);
WSACleanup();
return 1;
}
argument.lock = 1;
printf("Waiting for client to connect...\n");
pthread_create(&tid,NULL,timer,NULL);
while(TRUE){
argument.accpt = accept( ListenSocket, (SOCKADDR*)&client, &len );
if (argument.accpt == INVALID_SOCKET) {
printf("accept failed: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
} else {
printf("accept%s:%d\n",inet_ntoa(client.sin_addr),client.sin_port);
while (!argument.lock);
argument.lock = 0;
// sendto(argument.accpt,sendBuf,sizeof(sendBuf),0,(SOCKADDR*)&client,len);
pthread_create(&tid,NULL,transfer,&argument);
//send(AcceptSocket,sendBuf,sizeof(sendBuf),0);
}
}
// No longer need server socket
closesocket(ListenSocket);
WSACleanup();
return 0;
}
9. 求C语言下的TCP/IP协议的工作流程图
这个问题太专业了
给你点TCP/IP协议相关的介绍吧，希望可以对你有用，虽然你可能已经知道了。
TCP/IP协议介绍
TCP/IP的通讯协议
这部分简要介绍一下TCP/IP的内部结构，为讨论与互联网有关的安全问题打下基础。TCP/IP协议组之所以流行，部分原因是因为它可以用在各种各样的信道和底层协议（例如T1和X.25、以太网以及RS-232串行接口）之上。确切地说，TCP/IP协议是一组包括TCP协议和IP协议，UDP（User Datagram Protocol）协议、ICMP（Internet Control Message Protocol）协议和其他一些协议的协议组。
TCP/IP整体构架概述
TCP/IP协议并不完全符合OSI的七层参考模型。传统的开放式系统互连参考模型，是一种通信协议的7层抽象的参考模型,其中每一层执行某一特定任务。该模型的目的是使各种硬件在相同的层次上相互通信。这7层是:物理层、数据链路层、网路层、传输层、话路层、表示层和应用层。而TCP/IP通讯协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。这4层分别为：
应用层：应用程序间沟通的层，如简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。
传输层：在此层中，它提供了节点间的数据传送服务，如传输控制协议（TCP）、用户数据报协议（UDP）等，TCP和UDP给数据包加入传输数据并把它传输到下一层中，这一层负责传送数据，并且确定数据已被送达并接收。
互连网络层：负责提供基本的数据封包传送功能，让每一块数据包都能够到达目的主机（但不检查是否被正确接收），如网际协议（IP）。
网络接口层：对实际的网络媒体的管理，定义如何使用实际网络（如Ethernet、Serial Line等）来传送数据。
TCP/IP中的协议
以下简单介绍TCP/IP中的协议都具备什么样的功能，都是如何工作的：
1． IP
网际协议IP是TCP/IP的心脏，也是网络层中最重要的协议。
IP层接收由更低层（网络接口层例如以太网设备驱动程序）发来的数据包，并把该数据包发送到更高层---TCP或UDP层；相反，IP层也把从TCP或UDP层接收来的数据包传送到更低层。IP数据包是不可靠的，因为IP并没有做任何事情来确认数据包是按顺序发送的或者没有被破坏。IP数据包中含有发送它的主机的地址（源地址）和接收它的主机的地址（目的地址）。
高层的TCP和UDP服务在接收数据包时，通常假设包中的源地址是有效的。也可以这样说，IP地址形成了许多服务的认证基础，这些服务相信数据包是从一个有效的主机发送来的。IP确认包含一个选项，叫作IP source routing，可以用来指定一条源地址和目的地址之间的直接路径。对于一些TCP和UDP的服务来说，使用了该选项的IP包好像是从路径上的最后一个系统传递过来的，而不是来自于它的真实地点。这个选项是为了测试而存在的，说明了它可以被用来欺骗系统来进行平常是被禁止的连接。那么，许多依靠IP源地址做确认的服务将产生问题并且会被非法入侵。
2. TCP
如果IP数据包中有已经封好的TCP数据包，那么IP将把它们向‘上’传送到TCP层。TCP将包排序并进行错误检查，同时实现虚电路间的连接。TCP数据包中包括序号和确认，所以未按照顺序收到的包可以被排序，而损坏的包可以被重传。
TCP将它的信息送到更高层的应用程序，例如Telnet的服务程序和客户程序。应用程序轮流将信息送回TCP层，TCP层便将它们向下传送到IP层，设备驱动程序和物理介质，最后到接收方。
面向连接的服务（例如Telnet、FTP、rlogin、X Windows和SMTP）需要高度的可靠性，所以它们使用了TCP。DNS在某些情况下使用TCP（发送和接收域名数据库），但使用UDP传送有关单个主机的信息。
3.UDP
UDP与TCP位于同一层，但对于数据包的顺序错误或重发。因此，UDP不被应用于那些使用虚电路的面向连接的服务，UDP主要用于那些面向查询---应答的服务，例如NFS。相对于FTP或Telnet，这些服务需要交换的信息量较小。使用UDP的服务包括NTP（网落时间协议）和DNS（DNS也使用TCP）。
欺骗UDP包比欺骗TCP包更容易，因为UDP没有建立初始化连接（也可以称为握手）（因为在两个系统间没有虚电路），也就是说，与UDP相关的服务面临着更大的危险。
4.ICMP
ICMP与IP位于同一层，它被用来传送IP的的控制信息。它主要是用来提供有关通向目的地址的路径信息。ICMP的‘Redirect’信息通知主机通向其他系统的更准确的路径，而‘Unreachable’信息则指出路径有问题。另外，如果路径不可用了，ICMP可以使TCP连接‘体面地’终止。PING是最常用的基于ICMP的服务。
5. TCP和UDP的端口结构
TCP和UDP服务通常有一个客户/服务器的关系，例如，一个Telnet服务进程开始在系统上处于空闲状态，等待着连接。用户使用Telnet客户程序与服务进程建立一个连接。客户程序向服务进程写入信息，服务进程读出信息并发出响应，客户程序读出响应并向用户报告。因而，这个连接是双工的，可以用来进行读写。
两个系统间的多重Telnet连接是如何相互确认并协调一致呢？TCP或UDP连接唯一地使用每个信息中的如下四项进行确认：
源IP地址 发送包的IP地址。
目的IP地址 接收包的IP地址。
源端口 源系统上的连接的端口。
目的端口 目的系统上的连接的端口。
端口是一个软件结构，被客户程序或服务进程用来发送和接收信息。一个端口对应一个16比特的数。服务进程通常使用一个固定的端口，例如，SMTP使用25、Xwindows使用6000。这些端口号是‘广为人知’的，因为在建立与特定的主机或服务的连接时，需要这些地址和目的地址进行通讯。
相信大家都听说过TCP/IP这个词，这个词好像无处不在，时时都会在你面前跳出来。那TCP/IP到底是什么意思呢？
TCP/IP其实是两个网络基础协议：IP协议、TCP协议名称的组合。下面我们分别来看看这两个无处不在的协议。
IP协议
IP（Internet Protocol）协议的英文名直译就是：因特网协议。从这个名称我们就可以知道IP协议的重要性。在现实生活中，我们进行货物运输时都是把货物包装成一个个的纸箱或者是集装箱之后才进行运输，在网络世界中各种信息也是通过类似的方式进行传输的。IP协议规定了数据传输时的基本单元和格式。如果比作货物运输，IP协议规定了货物打包时的包装箱尺寸和包装的程序。 除了这些以外，IP协议还定义了数据包的递交办法和路由选择。同样用货物运输做比喻，IP协议规定了货物的运输方法和运输路线。
TCP协议
我们已经知道了IP协议很重要，IP协议已经规定了数据传输的主要内容，那TCP（Transmission Control Protocol）协议是做什么的呢？不知大家发现没有，在IP协议中定义的传输是单向的，也就是说发出去的货物对方有没有收到我们是不知道的。就好像8毛钱一份的平信一样。那对于重要的信件我们要寄挂号信怎么办呢？TCP协议就是帮我们寄“挂号信”的。TCP协议提供了可靠的面向对象的数据流传输服务的规则和约定。简单的说在TCP模式中，对方发一个数据包给你，你要发一个确认数据包给对方。通过这种确认来提供可靠性。
TCP/IP（Transmission Control Protocol/Internet Protocol的简写，中文译名为传输控制协议/互联网络协议）协议是Internet最基本的协议，简单地说，就是由底层的IP协议和TCP协议组成的。TCP/IP协议的开发工作始于70年代，是用于互联网的第一套协议。
1.1 TCP/IP参考模型
TCP/IP协议的开发研制人员将Internet分为五个层次，以便于理解，它也称为互联网分层模型或互联网分层参考模型，如下表：
应用层（第五层）
传输层（第四层）
互联网层（第三层）
网络接口层（第二层）
物理层（第一层）
物理层：对应于网络的基本硬件，这也是Internet物理构成，即我们可以看得见的硬设备，如PC机、互连网服务器、网络设备等，必须对这些硬设备的电气特性作一个规范，使这些设备都能够互相连接并兼容使用。
网络接口层：它定义了将资料组成正确帧的规程和在网络中传输帧的规程，帧是指一串资料，它是资料在网络中传输的单位。
互联网层：本层定义了互联网中传输的“信息包”格式，以及从一个用户通过一个或多个路由器到最终目标的"信息包"转发机制。
传输层：为两个用户进程之间建立、管理和拆除可靠而又有效的端到端连接。
应用层：它定义了应用程序使用互联网的规程。
1. 2 网间协议IP
Internet 上使用的一个关键的底层协议是网际协议，通常称IP协议。我们利用一个共同遵守的通信协议，从而使 Internet 成为一个允许连接不同类型的计算机和不同操作系统的网络。要使两台计算机彼此之间进行通信，必须使两台计算机使用同一种"语言"。通信协议正像两台计算机交换信息所使用的共同语言，它规定了通信双方在通信中所应共同遵守的约定。
计算机的通信协议精确地定义了计算机在彼此通信过程的所有细节。例如，每台计算机发送的信息格式和含义，在什么情况下应发送规定的特殊信息，以及接收方的计算机应做出哪些应答等等。
网际协议IP协议提供了能适应各种各样网络硬件的灵活性，对底层网络硬件几乎没有任何要求，任何一个网络只要可以从一个地点向另一个地点传送二进制数据，就可以使用IP协议加入 Internet 了。
如果希望能在 Internet 上进行交流和通信，则每台连上 Internet 的计算机都必须遵守IP协议。为此使用 Internet 的每台计算机都必须运行IP软件，以便时刻准备发送或接收信息。
IP协议对于网络通信有着重要的意义：网络中的计算机通过安装IP软件，使许许多多的局域网络构成了一个庞大而又严密的通信系统。从而使 Internet 看起来好像是真实存在的，但实际上它是一种并不存在的虚拟网络，只不过是利用IP协议把全世界上所有愿意接入 Internet 的计算机局域网络连接起来，使得它们彼此之间都能够通信。
1.3 传输控制协议TCP
尽管计算机通过安装IP软件，从而保证了计算机之间可以发送和接收资料，但IP协议还不能解决资料分组在传输过程中可能出现的问题。因此，若要解决可能出现的问题，连上 Internet 的计算机还需要安装TCP协议来提供可靠的并且无差错的通信服务。
TCP协议被称作一种端对端协议。这是因为它为两台计算机之间的连接起了重要作用：当一台计算机需要与另一台远程计算机连接时，TCP协议会让它们建立一个连接、发送和接收资料以及终止连接。
传输控制协议TCP协议利用重发技术和拥塞控制机制，向应用程序提供可靠的通信连接，使它能够自动适应网上的各种变化。即使在 Internet 暂时出现堵塞的情况下，TCP也能够保证通信的可靠。
众所周知， Internet 是一个庞大的国际性网络，网络上的拥挤和空闲时间总是交替不定的，加上传送的距离也远近不同，所以传输资料所用时间也会变化不定。TCP协议具有自动调整"超时值"的功能，能很好地适应 Internet 上各种各样的变化，确保传输数值的正确。
因此，从上面我们可以了解到：IP协议只保证计算机能发送和接收分组资料，而TCP协议则可提供一个可靠的、可流控的、全双工的信息流传输服务。