TCP_API接口函数实验

最新推荐文章于 2022-07-16 16:54:16 发布
最新推荐文章于 2022-07-16 16:54:16 发布
阅读量848 收藏
点赞数
分类专栏： 学习积累 文章标签： tcp api struct buffer null input
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bjut_xiaoli/article/details/7049535
版权
 

#include "sysinclude.h"   

  

extern void tcp_DiscardPkt(char* pBuffer, int type);     

extern void tcp_sendReport(int type);     

extern void tcp_sendIpPkt(unsigned char* pData, UINT16 len, unsigned int  srcAddr, unsigned int dstAddr, UINT8  ttl);     

extern int waitIpPacket(char *pBuffer, int timeout);     

extern unsigned int getIpv4Address();     

extern unsigned int getServerIpv4Address(); 

 

#define INPUT 0   

#define OUTPUT 1   

  

#define NOT_READY 0   

#define READY 1   

  

#define DATA_NOT_ACKED 0   

#define DATA_ACKED 1   

  

#define NOT_USED 0   

#define USED 1   

  

#define MAX_TCP_CONNECTIONS 5   

  

#define INPUT_SEG 0   

#define OUTPUT_SEG 1

  

typedef int STATE;  

     

enum TCP_STATES  

{  

    CLOSED,  

    SYN_SENT,  

    ESTABLISHED,  

    FIN_WAIT1,  

    FIN_WAIT2,  

    TIME_WAIT,  

}; 

 

int gLocalPort = 2007;  

int gRemotePort = 2006;  

int gSeqNum = 1234;  

int gAckNum = 0;  

  

struct MyTcpSeg  

{  

    unsigned short src_port;  

    unsigned short dst_port;  

    unsigned int seq_num;  

    unsigned int ack_num;  

    unsigned char hdr_len;  

    unsigned char flags;  

    unsigned short window_size;// ????????  

    unsigned short checksum;//??   

    unsigned short urg_ptr;   

    unsigned char data[2048];//???  

    unsigned short len;//????  

};  

  

struct MyTCB  

{  

    STATE current_state;  

    unsigned int local_ip;  

    unsigned short local_port;  

    unsigned int remote_ip;  

    unsigned short remote_port;  

    unsigned int seq;  

    unsigned int ack;  

    unsigned char flags;  

    int iotype;  

    int is_used;  

    int data_ack;  

    unsigned char data[2048];  

    unsigned short data_len;  

};  

  

struct MyTCB gTCB[MAX_TCP_CONNECTIONS];//TCB??  

int initialized = NOT_READY;//?????????   

  

int convert_tcp_hdr_ntoh(struct MyTcpSeg* pTcpSeg)//??????????????  

{  

    if( pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    pTcpSeg->src_port = ntohs(pTcpSeg->src_port);  

    pTcpSeg->dst_port = ntohs(pTcpSeg->dst_port);  

    pTcpSeg->seq_num = ntohl(pTcpSeg->seq_num);  

    pTcpSeg->ack_num = ntohl(pTcpSeg->ack_num);  

    pTcpSeg->window_size = ntohs(pTcpSeg->window_size);  

    pTcpSeg->checksum = ntohs(pTcpSeg->checksum);  

    pTcpSeg->urg_ptr = ntohs(pTcpSeg->urg_ptr);  

  

    return 0;  

}  

  

int convert_tcp_hdr_hton(struct MyTcpSeg* pTcpSeg)//??????????????  

{  

    if( pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    pTcpSeg->src_port = htons(pTcpSeg->src_port);  

    pTcpSeg->dst_port = htons(pTcpSeg->dst_port);  

    pTcpSeg->seq_num = htonl(pTcpSeg->seq_num);  

    pTcpSeg->ack_num = htonl(pTcpSeg->ack_num);  

    pTcpSeg->window_size = htons(pTcpSeg->window_size);  

    pTcpSeg->checksum = htons(pTcpSeg->checksum);  

    pTcpSeg->urg_ptr = htons(pTcpSeg->urg_ptr);  

  

    return 0;  

}  

  

unsigned short tcp_calc_checksum(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg) //??TCP?checksum 

{  

    int i = 0;  

    int len = 0;  

    unsigned int sum = 0;  

    unsigned short* p = (unsigned short*)pTcpSeg;  

  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return 0;  

    }  

  

    for( i=0; i<10; i++)  

    {  

        sum += p[i];  

    }  

  

    sum = sum - p[8] - p[6] + ntohs(p[6]);    

  

    if( (len = pTcpSeg->len) > 20 )  

    {  

        if( len % 2 == 1 )  

        {  

            pTcpSeg->data[len - 20] = 0;  

            len++;  

        }  

  

        for( i=10; i<len/2; i++ )  

        {  

            sum += ntohs(p[i]);  

        }  

    }    

  

    sum = sum + (unsigned short)(pTcb->local_ip>>16)  

        + (unsigned short)(pTcb->local_ip&0xffff)  

        + (unsigned short)(pTcb->remote_ip>>16)  

        + (unsigned short)(pTcb->remote_ip&0xffff);  

    sum = sum + 6 + pTcpSeg->len;  

    sum = ( sum & 0xFFFF ) + ( sum >> 16 );  

    sum = ( sum & 0xFFFF ) + ( sum >> 16 );  

  

    return (unsigned short)(~sum);  

}  

  

int get_socket(unsigned short local_port, unsigned short remote_port)  

{  

    int i = 1;  

    int sockfd = -1;  

  

    for( i=1; i<MAX_TCP_CONNECTIONS; i++ )  

    {  

        if( gTCB[i].is_used == USED  

            && gTCB[i].local_port == local_port  

            && gTCB[i].remote_port == remote_port )  

        {  

            sockfd = i;  

            break;  

        }  

    }  

  

    return sockfd;  

}  

  

int tcp_init(int sockfd)//???  

{  

    if( gTCB[sockfd].is_used == USED ) //????????

    {  

        return -1;  

    }  

  

    gTCB[sockfd].current_state = CLOSED;  

    gTCB[sockfd].local_ip = getIpv4Address();  

    gTCB[sockfd].local_port = gLocalPort + sockfd - 1;  

    //gTCB[sockfd].remote_ip = ntohl(getServerIpv4Address());    

    //gTCB[sockfd].remote_port = gDstPort;   

    gTCB[sockfd].seq = gSeqNum;  

    gTCB[sockfd].ack = gAckNum;  

    gTCB[sockfd].is_used = USED;  

    gTCB[sockfd].data_ack = DATA_ACKED;  

  

    return 0;  

}  

  

int tcp_construct_segment(struct MyTcpSeg* pTcpSeg, struct MyTCB* pTcb, unsigned short datalen, unsigned char* pData)  

{  

    pTcpSeg->src_port = pTcb->local_port;  

    pTcpSeg->dst_port = pTcb->remote_port;  

    pTcpSeg->seq_num = pTcb->seq;  

    pTcpSeg->ack_num = pTcb->ack;  

    pTcpSeg->hdr_len = (unsigned char)(0x50);  

    pTcpSeg->flags = pTcb->flags;  

    pTcpSeg->window_size = 1024;  

    pTcpSeg->urg_ptr = 0;  

  

    if( datalen > 0 && pData != NULL )  

    {  

        memcpy(pTcpSeg->data, pData, datalen);  

    }  

  

    pTcpSeg->len = 20 + datalen;  

  

    return 0;  

}  

  

int tcp_kick(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    pTcpSeg->checksum = tcp_calc_checksum(pTcb, pTcpSeg);  

  

    convert_tcp_hdr_hton(pTcpSeg);   

  

    tcp_sendIpPkt((unsigned char*)pTcpSeg, pTcpSeg->len, pTcb->local_ip, pTcb->remote_ip, 255);  

  

    //memcpy(&(pTcb->last_seg), pTcpSeg, pTcpSeg->len);   

  

    if( (pTcb->flags & 0x0f) == 0x00 )   ///发送了一个data报文同时seq+=n

    {  

        //data   

        pTcb->seq += pTcpSeg->len - 20;  

    }  

    else if( (pTcb->flags & 0x0f) == 0x02 )  

    {  

        //syn   

        pTcb->seq++;  

    }  

    else if( (pTcb->flags & 0x0f) == 0x01 )  

    {  

        //fin   

        pTcb->seq++;  

    }  

    else if( (pTcb->flags & 0x3f) == 0x10 )  

    {  

        //ack   

    }  

  

    return 0;  

}  

  

int tcp_closed(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    if( pTcb->iotype != OUTPUT )  

    {  

        //to do: discard packet   

  

        return -1;  

    }  

  

    pTcb->current_state = SYN_SENT;  

    pTcb->seq = pTcpSeg->seq_num ;  

  

    tcp_kick( pTcb, pTcpSeg );  

  

    return 0;  

}  

  

int tcp_syn_sent(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    struct MyTcpSeg my_seg;  

  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    if( pTcb->iotype != INPUT )  

    {  

        return -1;  

    }  

  

    if( (pTcpSeg->flags & 0x3f) != 0x12 )  

    {  

        //to do: discard packet   

  

        return -1;  

    }  

  

    pTcb->ack = pTcpSeg->seq_num + 1;  

    pTcb->flags = 0x10;  

  

    tcp_construct_segment( &my_seg, pTcb, 0, NULL );  

    tcp_kick( pTcb, &my_seg );  

  

    pTcb->current_state = ESTABLISHED;  

  

    return 0;  

}  

  

int tcp_established(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    struct MyTcpSeg my_seg;  

  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    if( pTcb->iotype == INPUT )  

    {  

        if( pTcpSeg->seq_num != pTcb->ack )  

        {  

            tcp_DiscardPkt((char*)pTcpSeg, STUD_TCP_TEST_SEQNO_ERROR);  

            //to do: discard packet   

  

            return -1;  

        }  

  

        if( (pTcpSeg->flags & 0x3f) == 0x10 )  

        {  

            //get packet and ack it   

            memcpy(pTcb->data, pTcpSeg->data, pTcpSeg->len - 20);  

            pTcb->data_len = pTcpSeg->len - 20;  

  

            if( pTcb->data_len == 0 )  

            {  

                //pTcb->ack = pTcpSeg->seq_num + 1;   

                //pTcb->ack++;   

            }  

            else  

            {  

                pTcb->ack += pTcb->data_len;  

                pTcb->flags = 0x10;  

                tcp_construct_segment(&my_seg, pTcb, 0, NULL);  

                tcp_kick(pTcb, &my_seg);  

            }  

        }  

    }  

    else  

    {  

        if( (pTcpSeg->flags & 0x0F) == 0x01 )  

        {  

            pTcb->current_state = FIN_WAIT1;  

        }  

  

        tcp_kick( pTcb, pTcpSeg );  

    }  

  

    return 0;  

}  

  

int tcp_finwait_1(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    if( pTcb->iotype != INPUT )  

    {  

        return -1;  

    }  

  

    if( pTcpSeg->seq_num != pTcb->ack )  

    {  

        tcp_DiscardPkt((char*)pTcpSeg, STUD_TCP_TEST_SEQNO_ERROR);  

  

        return -1;  

    }  

  

    if( (pTcpSeg->flags & 0x3f) == 0x10 && pTcpSeg->ack_num == pTcb->seq )  

    {  

        pTcb->current_state = FIN_WAIT2;  

        //pTcb->ack++;   

    }  

  

    return 0;  

}  

  

int tcp_finwait_2(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    struct MyTcpSeg my_seg;  

  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    if( pTcb->iotype != INPUT )  

    {  

        return -1;  

    }  

  

    if( pTcpSeg->seq_num != pTcb->ack )  

    {  

        tcp_DiscardPkt((char*)pTcpSeg, STUD_TCP_TEST_SEQNO_ERROR);  

  

        return -1;  

    }  

  

    if( (pTcpSeg->flags & 0x0f) == 0x01 )  

    {  

        pTcb->ack++;  

        pTcb->flags = 0x10;  

  

        tcp_construct_segment( &my_seg, pTcb, 0, NULL );  

        tcp_kick( pTcb, &my_seg );   

        pTcb->current_state = CLOSED;  

    }  

    else  

    {  

        //to do   

    }  

  

    return 0;  

}  

  

int tcp_time_wait(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    pTcb->current_state = CLOSED;  

    //to do   

  

    return 0;  

}  

  

int tcp_check(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    int i = 0;  

    int len = 0;  

    unsigned int sum = 0;  

    unsigned short* p = (unsigned short*)pTcpSeg;  

    unsigned short *pIp;  

    unsigned int myip1 = pTcb->local_ip;  

    unsigned int myip2 = pTcb->remote_ip;  

  

    if( pTcb == NULL || pTcpSeg == NULL )  

    {  

        return -1;  

    }  

  

    for( i=0; i<10; i++)  

    {  

        sum = sum + p[i];  

    }  

    sum = sum - p[6] + ntohs(p[6]);  

  

    if( (len = pTcpSeg->len) > 20 )  

    {  

        if( len % 2 == 1 )  

        {  

            pTcpSeg->data[len - 20] = 0;  

            len++;  

        }  

  

        for( i=10; i<len/2; i++ )  

        {   

            sum += ntohs(p[i]);  

        }  

    }  

  

    sum = sum + (unsigned short)(myip1>>16)  

        + (unsigned short)(myip1&0xffff)  

        + (unsigned short)(myip2>>16)  

        + (unsigned short)(myip2&0xffff);  

    sum = sum + 6 + pTcpSeg->len;  

  

    sum = ( sum & 0xFFFF ) + ( sum >> 16 );  

    sum = ( sum & 0xFFFF ) + ( sum >> 16 );  

  

    if( (unsigned short)(~sum) != 0 )  

    {  

        // TODO:   

        printf("check sum error!\n");  

  

        return -1;  

        //return 0;   

    }  

    else  

    {  

        return 0;  

    }  

}  

  

int tcp_switch(struct MyTCB* pTcb, struct MyTcpSeg* pTcpSeg)  

{  

    int ret = 0;  

  

    printf("STATE: %d\n", pTcb->current_state);  

  

    switch(pTcb->current_state)  

    {  

    case CLOSED:  

        ret = tcp_closed(pTcb, pTcpSeg);  

        break;  

    case SYN_SENT:  

        ret = tcp_syn_sent(pTcb, pTcpSeg);  

        break;  

    case ESTABLISHED:  

        ret = tcp_established(pTcb, pTcpSeg);  

        break;  

    case FIN_WAIT1:  

        ret = tcp_finwait_1(pTcb, pTcpSeg);  

        break;  

    case FIN_WAIT2:  

        ret = tcp_finwait_2(pTcb, pTcpSeg);  

        break;  

    case TIME_WAIT:  

        ret = tcp_time_wait(pTcb, pTcpSeg);  

        break;  

    default:  

        ret = -1;  

        break;  

    }  

  

    return ret;  

}  

  

int stud_tcp_input(char* pBuffer, unsigned short len, unsigned int srcAddr, unsigned int dstAddr)  

{  

    //construct MyTcpSeg from buffer   

    struct MyTcpSeg tcp_seg;  

    int sockfd = -1;  

  

    //printf("Here len = %d\n", len);   

  

    if( len < 20 )  

    {  

        return -1;  

    }  

  

    if(initialized == NOT_READY)  

    {  

        tcp_init(1);  

        gTCB[1].remote_ip = getServerIpv4Address();  

        gTCB[1].remote_port = gRemotePort;  

        initialized = READY;  

    }  

  

    memcpy(&tcp_seg, pBuffer, len);  

  

    tcp_seg.len = len;  

  

    //convert bytes' order   

    convert_tcp_hdr_ntoh(&tcp_seg);  

  

    sockfd = get_socket(tcp_seg.dst_port, tcp_seg.src_port);  

  

    if( sockfd == -1 || gTCB[sockfd].local_ip != ntohl(dstAddr) || gTCB[sockfd].remote_ip != ntohl(srcAddr) )  

    {  

        printf("sock error in stud_tcp_input()\n");  

        return -1;  

    }  

  

    //gTCB.local_ip = ntohl(dstAddr);   

    //gTCB.remote_ip = ntohl(srcAddr);   

  

    //check TCP checksum   

    if( tcp_check(&gTCB[sockfd], &tcp_seg) != 0 )  

    {  

        return -1;  

    }  

  

    gTCB[sockfd].iotype = INPUT;  

    memcpy(gTCB[sockfd].data,tcp_seg.data,len - 20);  

    gTCB[sockfd].data_len = len - 20;  

  

    tcp_switch(&gTCB[sockfd], &tcp_seg);  

  

    return 0;  

}  

  

void stud_tcp_output(char* pData, unsigned short len, unsigned char flag, unsigned short srcPort, unsigned short dstPort, unsigned int srcAddr, unsigned int dstAddr)  

{  

    struct MyTcpSeg my_seg;  

    int sockfd = -1;  

  

    if(initialized == NOT_READY)  

    {  

        tcp_init(1);  

        gTCB[1].remote_ip = getServerIpv4Address();  

        gTCB[1].remote_port = gRemotePort;  

        initialized = READY;  

    }  

  

    sockfd = get_socket(srcPort, dstPort);  

  

    if( sockfd == -1 || gTCB[sockfd].local_ip != srcAddr || gTCB[sockfd].remote_ip != dstAddr )  

    {  

        return;  

    }  

  

    gTCB[sockfd].flags = flag;  

    //gTCB.local_port = srcPort;   

    //gTCB.local_ip = ntohl(srcAddr);   

    //gTCB.remote_port = dstPort;   

    //gTCB.remote_ip = ntohl(dstAddr);   

  

    tcp_construct_segment(&my_seg, &gTCB[sockfd], len, (unsigned char *)pData);  

  

    gTCB[sockfd].iotype = OUTPUT;  

  

    tcp_switch(&gTCB[sockfd], &my_seg);  

}  

  

int stud_tcp_socket(int domain, int type, int protocol)  

{  

    int i = 1;  

    int sockfd = -1;  

  

    if( domain != AF_INET || type != SOCK_STREAM || protocol != IPPROTO_TCP )  

    {  

        return -1;  

    }  

  

    for( i=1; i<MAX_TCP_CONNECTIONS; i++ )  

    {  

        if( gTCB[i].is_used == NOT_USED )  

        {  

            sockfd = i;  

  

            if( tcp_init(sockfd) == -1 )  

            {  

                return -1;  

            }  

  

            break;  

        }  

    }  

  

    initialized = READY;  

  

    return sockfd;  

}  

  

int stud_tcp_connect(int sockfd, struct sockaddr_in* addr, int addrlen)  

{  

    char buffer[2048];  

    int len;  

  

    gTCB[sockfd].remote_ip = ntohl(addr->sin_addr.s_addr);  

    gTCB[sockfd].remote_port = ntohs(addr->sin_port);  

  

    stud_tcp_output( NULL, 0, 0x02, gTCB[sockfd].local_port, gTCB[sockfd].remote_port, gTCB[sockfd].local_ip, gTCB[sockfd].remote_ip );  

  

    len = waitIpPacket(buffer, 10);  

  

    if( len < 20 )  

    {  

        return -1;  

    }  

  

    if (stud_tcp_input(buffer, len, htonl(gTCB[sockfd].remote_ip), htonl(gTCB[sockfd].local_ip)) != 0){  

        return 1;  

    }  

    else  

    {  

        return 0;  

    }  

}   

  

int stud_tcp_send(int sockfd, const unsigned char* pData, unsigned short datalen, int flags)  

{  

    char buffer[2048];  

    int len;  

  

    if( gTCB[sockfd].current_state != ESTABLISHED )  

    {  

        return -1;  

    }  

  

    stud_tcp_output((char *)pData, datalen, flags, gTCB[sockfd].local_port, gTCB[sockfd].remote_port, gTCB[sockfd].local_ip, gTCB[sockfd].remote_ip);  

  

    len = waitIpPacket(buffer, 10);  

  

    if( len < 20 )  

    {  

        return -1;  

    }   

  

    stud_tcp_input(buffer, len, htonl(gTCB[sockfd].remote_ip), htonl(gTCB[sockfd].local_ip));  

  

    return 0;  

}  

  

int stud_tcp_recv(int sockfd, unsigned char* pData, unsigned short datalen, int flags)  

{  

    char buffer[2048];  

    int len;  

  

    if( (len = waitIpPacket(buffer, 10)) < 20 )  

    {  

        return -1;  

    }  

  

    stud_tcp_input(buffer, len,  htonl(gTCB[sockfd].remote_ip),htonl(gTCB[sockfd].local_ip));  

  

    memcpy(pData, gTCB[sockfd].data, gTCB[sockfd].data_len);  

  

    return gTCB[sockfd].data_len;  

}  

  

int stud_tcp_close(int sockfd)  

{  

    char buffer[2048];  

    int len;  

  

    stud_tcp_output(NULL, 0, 0x11, gTCB[sockfd].local_port, gTCB[sockfd].remote_port, gTCB[sockfd].local_ip, gTCB[sockfd].remote_ip);  

  

    //recv ACK   

    if( (len = waitIpPacket(buffer, 10)) < 20 )  

    {  

        return -1;  

    }  

  

    stud_tcp_input(buffer, len, htonl(gTCB[sockfd].remote_ip), htonl(gTCB[sockfd].local_ip));  

  

    //recv FIN   

    if( (len = waitIpPacket(buffer, 10)) < 20 )  

    {  

        return -1;  

    }  

  

    stud_tcp_input(buffer, len, htonl(gTCB[sockfd].remote_ip), htonl(gTCB[sockfd].local_ip));  

  

    gTCB[sockfd].is_used = NOT_USED;  

  

    return 0;  

}

工大小李
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TCP连接相关的API
li1358159的博客
10-03 465
在建立和终止TCP连接的时候，通信两端会发送一些带有特殊标记（如SYN、ACK、FIN、RST）的报文，并维护各自的状态。
TCP_IP网络实验程序篇
01-11
4. **Linux内核网络开发**：Linux内核提供了丰富的网络编程接口，如套接字API，使得开发者可以直接与TCP/IP协议栈交互，创建各种网络应用。 5. **网络编程**：包括客户端和服务器端编程，如使用socket函数创建套接...
socket编程1 tcp基本api接口与基础编程demo
随风的博客
09-15 462
TCP socket编程 学习TCP socket编程API接口，基于此入门，并编写一个TCP网络服务器与通讯客户机。 keyword: TCP socket API接口 #include <sys/socket.h> int socket(int family, int type, int protocal); // 创建一个套接字，并配置 int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen)
网络编程之基本TCP套接口函数解析
kingdow-liu
05-04 1136
在介绍 tcp 套接口相关函数之前，我们先看一下客户端-服务端 tcp 连接全过程。 以上的过程有助于我们理解下面的函数，以下的函数均对应上述过程中的操作 socket 函数 int socket(int family, int type, int protocol); 函数功能：指定期望的通信协议类型，产生一个监听套接字。 参数： family：指明协议族，取值可以为AF_INET(IP...
TCP核心API讲解
renfujiang的专栏
02-17 494
1、Socket()，创建一个Socket。构造方法的时候创建一个无连接无绑定的空状态，创建好了之后再进行细微的配置。 2、bind(),绑定一个socket到一个本地地址和端口上。 3、服务端其实是创建ServerSocket(),监听来自客户端的套接字， 4、连接到远程套接字 5，accept():接收一个新的连接。 6，write():把数据写入到Socket输出流 7，read...
TCP-API
zuiyijiangnan的博客
08-17 237
服务器 1、创建socket文件描述符，使用socket函数（协议类型IPv4或者IPv6) int socket(int domain, int type,int protocol) 该函数返回一个socket文件描述符 Domain: 协议域常用的有AF_INET(IPv4)、AF_INET6(IPv6)、AF_LOCAL(或称AF_UNIX)、AF_ROUTE等；指定在通信中使用的通信地址。例如AF_INET 则需要使用IPv4地址 Type:指定socket的类型，常用的有...
tcp.rar_LINUX TCP _tcp
最新发布
09-19
本实验旨在深入理解和实践Linux环境下的TCP编程，通过socket接口来实现。 首先，我们需要了解Linux下的TCP编程基础。TCP编程主要涉及到以下几个关键概念： 1. **Socket接口**：它是应用层与传输层之间的一个抽象...
实验报告_TCP/IP_C++_WINSOCK_MFC_
10-03
在本实验报告中，我们将深入探讨如何利用C++编程语言，结合Windows Socket（Winsock）API，以及Microsoft Foundation Classes（MFC）库来实现TCP/IP协议下的文件传输功能。MFC是一个面向对象的C++库，它为Windows...
stm32f407-TCP客户端数据收发实验_stm32f407_stm32f407TCP客户端_
09-30
2. **创建TCP连接**：使用 lwIP 提供的API创建一个TCP连接。例如，`tcp_connect()` 函数用于连接到远程服务器的指定端口。需要提供服务器的IP地址和端口号。 3. **发送数据**：连接建立后，可以使用 `tcp_write()` ...
Winsock编程接口实验源码
07-19
此外，获取MAC地址通常需要使用底层的网络接口函数，如`sendto()`和`recvfrom()`，配合特定的协议如ARP（地址解析协议）。 实验文件"WinSockTest01"很可能是实现这两个功能的源代码文件。这个文件可能包含了必要的...
TCP协议测试连接工具（很实用）
11-17
测试TCP连接的工具，用起来很方便，开发时可以当做小工具测试用，也可以用在测试端口通不通等，喜欢的朋友可以使用。
简单TCP协议实验
05-19
基于网络协议开发实验平台的TCP实验，接口函数tcp_DiscardPkt，tcp_sendIpPkt，waitIpPacket，getIpv4Address，getServerIpv4Address。 实现函数stud_tcp_input，stud_tcp_output，stud_tcp_socket，stud_tcp_connect，stud_tcp_send，stud_tcp_recv，stud_tcp_close。 并非完全正确，但比流行代码更符合实验要求，留有一点瑕疵，望后人改正.
Linux 通信套接字及其API接口函数的本质（以TCP为例）
challenglistic的博客
07-16 647
Linux下一切皆文件，套接字必然和文件脱不开关系，下面就站在文件系统角度分析套接字及其接口函数在通信过程中做了哪些工作？？
基本TCP套接口编程函数
liziyun537的专栏
11-13 564
<br /><br /><br /> <br /><br /><br /><br /><br /><br /><br /><br /> 
【操作系统】网络3（TCP的API）
博客
07-08 332
前面一篇文章介绍了 UDP ，接下来介绍另外一组 API TCP 的 socket API UDP特点：无连接，不可靠，面向数据报，全双工 TCP特点：有链接，可靠性，面向字节流，全双工 全双工：双向通信，借助一个 socket 对象，既可以发送数据，也能接收数据 半双工：单向通信，要么只能读，要么只能写 TCP 的 API TCP 的 API 也涉及到两个核心的类 ServerSocket Socket 和 UDP 差别较大（差别也就体现在 UDP 和 TCP 之间的特性的区别上） .
第三十三篇，网络编程TCP协议通讯过程实现和函数接口
weixin_44651073的博客
04-14 2584
网络编程知识点概览
网络原理和TCP传输,supplier接口,consumer接口,函数式接口
qq_40953756的博客
08-31 178
软件结构 c/s结构(client/server):客户端/服务器结构,开发成本高,服务器端压力小 b/s结构(borwser/server):浏览器/服务器结构,成本低,服务器端压力大 网络通讯的三要素 IP地址:网络设备的唯一标识 端口号:每一个进程(程序)的唯一标识 协议:用来确定计算机和计算机之间的数据传输格式.分为UDP协议和TCP协议...
简单的服务器 TCP版本 熟悉其 API 【网络】
一朵花花
01-05 458
Java 标准库中提供了两种风格 DatagramSocket：面向数据报 ServerSocket：面向字节流
Windows Sockets API实现网络异步通讯
深之JohnChen的专栏
12-11 1924
摘要：本文对如何使用面向连接的流式套接字实现对网卡的编程以及如何实现异步网络通讯等问题进行了讨论与阐述。 　　一、 引言　　在80年代初，美国加利福尼亚大学伯克利分校的研究人员为TCP/IP网络通信开发了一个专门用于网络通讯开发的API。这个API就是Socket接口（套接字）--当今在TCP/IP网络最为通用的一种API，也是在互联网上进行应用开发最为通用的一种API。在微软联合其它几家公司共同

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值