网络编程1 网络开发基础(Socket、TCP、UDP)

/* 套接字 */  
/* 
 * 函数功能：创建套接字描述符； 
 * 返回值：若成功则返回套接字非负描述符，若出错返回-1； 
 * 返回值：函数执行成功将返回新创建的套接字句柄，否则，将返回INVALID_SOCKET表示失败
 * 函数原型： 
 */  
#include<sys/types.h> //提供各种数据类型的定义
#include <sys/socket.h> //提供socket函数及其数据结构的定义

int socket(int family, int type, int protocol);  
/* 
 * 说明： 
 * socket类似与open对普通文件操作一样，都是返回描述符，后续的操作都是基于该描述符； 
 * family 表示套接字的通信域，不同的取值决定了socket的地址类型，其一般取值如下： 
 * （1）AF_INET         IPv4因特网域 
 * （2）AF_INET6        IPv6因特网域 
 * （3）AF_UNIX         Unix域 
 * （4）AF_ROUTE        路由套接字 
 * （5）AF_KEY          密钥套接字 
 * （6）AF_UNSPEC       未指定 
 * 
 * type确定socket的类型，常用类型如下： 
 * （1）SOCK_STREAM     有序、可靠、双向的面向连接字节流套接字（TCP）
 * （2）SOCK_DGRAM      长度固定的、无连接的不可靠数据报套接字 (UDP)
 * （3）SOCK_RAW        原始套接字 
 * （4）SOCK_SEQPACKET  长度固定、有序、可靠的面向连接的有序分组套接字 
 * 
 * protocol指定协议，常用取值如下： 
 * （1）0               选择type类型对应的默认协议 
 * （2）IPPROTO_TCP     TCP传输协议 
 * （3）IPPROTO_UDP     UDP传输协议 
 * （4）IPPROTO_SCTP    SCTP传输协议 
 * （5）IPPROTO_TIPC    TIPC传输协议 
 * 
 */   

/* 套接字的基本操作 */  

/* 
 * 函数功能：将协议地址绑定到一个套接字；其中协议地址包含IP地址和端口号； 
 * 返回值：若成功则返回0，若出错则返回-1； 
 * 函数原型： 
 */  
#include<sys/types.h>
#include <sys/socket.h>  
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);  
/* 
 * 说明： 
 * sockfd 为套接字描述符； 
 * addr是一个指向特定协议地址结构的指针，协议地址结构包含IP地址和端口号； 
 * addrlen是地址结构的长度，常被设置为sizeof(struct sockaddr)； 
 */  

struct sockaddr{
    unsigned short sa_family; //地址族,AF_xxx 
    char sa_data[14]; //14字节的协议地址
};

struct  sockaddr_in{
    short int sin_family; //地址族
    unsigned short int sin_port; //端口号
    struct in_addr sin_addr; //IP地址
    unsigned char sin_zero[8];//填充0,以保持与struct sockaddr 同样大小
}

struct in_addr{
    union{
        struct{
            unsigned char s_b1,s_b2,s_b3,s_b4; 
        }S_un_b; //用4个u_char字符描述IP地址

        struct{
            unsigned short s_w1,s_w2;
        }S_un_w； //用两个u_short类型描述IP地址
        unsigned long S_addr; //用一个u_long类型描述IP地址
    }S_un;
};

MyAddr.sin_port=0;//系统随机选择一个未被使用的端口号
MyAddr.sin_addr.s_addr=INADDR_ANY; //填入本地IP地址

/* 
 * 函数功能：建立连接，即客户端使用该函数来建立与服务器的连接； 
 * 返回值：若成功则返回0，出错则返回-1； 
 * 函数原型： 
 */  
#include <sys/socket.h>  
#include<sys/types.h>
int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);  
/* 
 * 说明： 
 * sockfd是系统调用的套接字描述符，即由socket函数返回的套接字描述符； 
 * servaddr是目的套接字的地址，该套接字地址结构必须包含目的IP地址和目的端口号，即想与之通信的服务器地址； 
 * addrlen是目的套接字地址的大小； 
 * 
 * 如果sockfd没有绑定到一个地址，connect会给调用者绑定一个默认地址，即内核会确定源IP地址，并选择一个临时端口号作为源端口号； 
 */  

/* 
 * 函数功能：接收连接请求； 
 * 函数原型： 
 */  
#include <sys/socket.h>  
#include<sys/types.h>
int listen(int sockfd, int backlog);//若成功则返回0，若出错则返回-1；  
/* 
 * sockfd是套接字描述符； 
 * backlog是该进程所要入队请求的最大请求数量，进入的连接请求将在队列中等待accept。backlog对队列中等待服务请求的数目进行了限制，大多数系统默认值为20.如果一个服务请求到来时，输入队列已满，该Socket将拒绝服务连接请求，客户端收到一个出错信息； 
 */  

//accept()函数的原型如下： 
#include<sys/types.h>
#include<sys/socket.h>
int accept(int sockfd,sturct sockaddr *addr,socklen_t *addrlen);
/*
sockfd:是系统函数socket()返回的套接字描述符
addr:是一个回传的指向数据结构sockaddr的指针，accept()函数将从客户的连接请求之中自动抽取远端客户主机的端点地址信息并存入到该指针所指向的数据结构之中。
addrlen:远端地址结构addr的长度，可以用sizeof(struct sockaddr)来获取。
*/

char *msg = "Hello World!"; 
int nlen=strlen(msg); //数据的长度
int nslen=0;//用于保存已经发送的长度
while(nslen<nlen){
    nslen+=send(sock,msg+nslen,(nlen-nslen),0);
}

struct hostent 
{ 
     char *h_name;        /* 主机的官方域名 */ 
     char **h_aliases;    /* 一个以NULL结尾的主机别名数组 */ 
     int    h_addrtype;   /* 返回的地址类型，在Internet环境下为AF-INET */ 
     int h_length;        /*地址的字节长度 */ 
     char **h_addr_list;  /* 一个以0结尾的数组，包含该主机的所有地址*/ 
}; 
#define h_addr h_addr_list[0] /*在h-addr-list中的第一个地址*/

#include<cstdio>
#include<winsock2.h>

#pragma comment(lib,"ws2_32.lib");
#define PORT 8888
#define BACKLOG 20 
int main(){
    WORD sockVersion =MAKEWORD(2,2);
    WSADATA wsaData;
    if(WSAStartup(sockVersion,&wsaData)!=0){
        printf("初始化套接字库失败\n");
        return 0;
    }
    int slisten; 
    if((slisten=socket(AF_INET,SOCK_STREAM,0))==-1){
        printf("socket error!\n");
        return 0;
    }
    sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(PORT);
    addr.sin_addr.s_addr=INADDR_ANY;
    printf("本地ip地址：%s\n",inet_ntoa(addr.sin_addr));
    if(bind(slisten,(sockaddr *)&addr,sizeof(addr))==-1){
        printf("bind error\n");
        closesocket(slisten);
        return 0;
    }
    if(listen(slisten,BACKLOG)==-1){
        printf("listen error\n");
        closesocket(slisten);
        return 0;
    }
    int sClient;
    sockaddr_in remoteAddr;
    int sin_size=sizeof(struct sockaddr_in);
    char revData[255];
    while(true){
        printf("等待连接...\n");
        if((sClient=accept(slisten,(struct sockaddr *)&remoteAddr,&sin_size))==-1){
            printf("accept error!\n");
            closesocket(slisten);
            continue;
        }
        printf("接受到一个连接:%s\n",inet_ntoa(remoteAddr.sin_addr));
        //接受数据 
        int ret=recv(sClient,revData,255,0);
        if(ret>0){
            revData[ret]=‘\0‘;
            printf("%s\n",revData);
        }
        //const char *sendData ="你好,TCP客户端!\n"; 
        char sendData[255];
        scanf("%s",sendData);
        send(sClient,sendData,strlen(sendData),0);
        closesocket(sClient);
    }
    closesocket(slisten);
    WSACleanup();
    return 0;
}

#include<cstdio>
#include<cstring>
#include<iostream>
#include<winsock2.h> 

#pragma comment(lib,"ws2_32.lib")
#define PORT 8888
using namespace std;
int main(){
    WORD sockVersion = MAKEWORD(2, 2);
    WSADATA data;
    if(WSAStartup(sockVersion, &data)!=0){
        printf("初始化套接字库失败\n");
        return 0;
    }

    int sClient;
    if((sClient=socket(AF_INET, SOCK_STREAM,0))==-1){
        printf("socket error!");
            return 0;
    }
    sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr= inet_addr("127.0.0.1");
    if(connect(sClient,(sockaddr *)&addr,sizeof(addr))==-1){
        printf("connect error !");
        closesocket(sClient);
        return 0;
    }   
    //发送数据 
    const char * sendData;
    scanf("%s",sendData);

    send(sClient, sendData, strlen(sendData), 0);

    //接收数据 
    char recData[255];
    int ret = recv(sClient, recData, 255, 0);
    if(ret>0){
        recData[ret]=‘\0‘;
        printf("%s\n",recData);
    } 
    closesocket(sClient);

    WSACleanup();
    return 0;
}

#include<winsock2.h>
#include<cstdio>
#pragma comment(lib,"WS2_32.lib")
#define PORT 8888
#define BACKLOG 20

int main() {
    WSADATA data;
    WORD w=MAKEWORD(2,2);
    if(WSAStartup(w,&data)!=0){
        printf("初始化套接字库失败\n");
        return 0;
    }
    int slisten;
    if((slisten=socket(AF_INET,SOCK_DGRAM,0))==INVALID_SOCKET){
        printf("socket error\n");
        return 0;
    }
    sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(PORT);
    addr.sin_addr.S_un.S_addr=INADDR_ANY;
    printf("本地ip地址：%s\n",inet_ntoa(addr.sin_addr));
    if(bind(slisten,(sockaddr *)&addr,sizeof(addr))==-1){
        printf("bind error\n");
        closesocket(slisten);
        return 0;
    } 
    char recvData[255];
    char sendData[255];
    sockaddr_in remoteAddr;
    int n=sizeof(remoteAddr);
    while(1){
        printf("等待连接...\n"); 
        int ret=recvfrom(slisten,recvData,255,0,(sockaddr *)&remoteAddr,&n);
        printf("接受到一个连接:%s\n",inet_ntoa(remoteAddr.sin_addr));
        if(ret>0){
            recvData[ret]=‘\0‘;
            printf("%s\n",recvData);
        }
        scanf("%s",sendData);
        sendto(slisten,sendData,sizeof(sendData),0,(sockaddr *)&remoteAddr,n);
    }
    closesocket(slisten);
    WSACleanup();
}

#include<winsock2.h>
#include<cstdio>

#pragma comment(lib,"WS2_32.lib")
#define PORT 8888

int main(){
    WSADATA data;
    WORD w=MAKEWORD(2,2);
    if(WSAStartup(w,&data)!=0){
        printf("初始化套接字库失败\n");
        return 0;
    }
    int sClient;
    if((sClient=socket(AF_INET,SOCK_DGRAM,0))==INVALID_SOCKET){
        printf("socket error\n");
        return 0;
    }
    sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(PORT);
    addr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
    char recvData[255],sendData[255];
    sockaddr_in remoteAddr;
    int n=sizeof(remoteAddr);
    scanf("%s",sendData);
    sendto(sClient,sendData,sizeof(sendData),0,(sockaddr *)&addr,sizeof(addr)); 
    recvfrom(sClient,recvData,255,0,(sockaddr *)&remoteAddr,&n);
    printf("%s\n",recvData);
    closesocket(sClient);
    WSACleanup();
}