linux 高级网络编程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了linux 高级网络编程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11954字，纯文字阅读大概需要18分钟。

内容图文

转自：http://www.cnblogs.com/coder2012/archive/2013/03/31/2991785.html

设置套接字函数：

#include<sys/socket.h>

int setsockopt(int sockfd, int level, int optname, constvoid* optval, socklen_t* optlen);

//sockfd要设置的目的套接字
//level套接字的控制层次
//optname optval optlen是三个相关的参数，通过不同的搭配可以设置不同的功能

应用：

1.数据收发时限设置

            struct
             timeva timeout;
timeout.tv_sec=5;
timeout.tv_usec=0;

//接受时限
setsockopt(serversocket, SQL_SOCKET,SO_RCVTIMEO, (char*)&timeout,sizeof(timeout));

//发送时限
setsockopt(serversocket, SQL_SOCKET,SO_SNDTIMEO, (char*)&timeout,sizeof(timeout));

2.修改收发缓冲区

            //
            接收缓冲区
            int opt=1024*1024;
setsockopt(serversocket, SQL_SOCKET, SO_RCVBUF, (constchar*)&opt,sizeof(opt));


//发送缓冲区
setsockopt(serversocket, SQL_SOCKET, SO_SNDBUF, (constchar*)&opt,sizeof(opt));

3.广播设置

            int bBroadcast=1;
setsockopt(seversocket, SQL_SOCKET, SO_BROADCAST,(cosnt char*)&bBroadcast,sizeof(bBroadcast));

4.直接数据复制

　　为了提升系统性能，在发送或接受数据时，可以主动设置数据不经历由缓冲区到套接字缓存区的拷贝。

            int opt=0;

setsockopt(serversocket, SQL_SOCKET,SO_SNDBUF,(char*)&opt,sizeof(opt));

setsockopt(serversocket, SQL_SOCKET,SO_RCVBUF,(char*)&opt,sizeof(opt));

Select技术：

#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

#define SERVER_PORT 5555
#define QUEUE_LENGTH 5
#define BUF_SIZE 200

int main(int argc, char **argv)
{
    int server_socket,new_socket;
    struct sockaddr_in server_addr,client_addr;
    socklen_t sin_size;
    int client_socket[QUEUE_LENGTH];
    int conn_num;
    int yes=1;
    char buf[BUF_SIZE];
    int ret;
    int i;
    //创建套接字if((server_socket=socket(AF_INET,SOCK_STREAM,0))<0){
        perror("Socket");
        return0;
    }
    //设置为可重复使用if(setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int))==-1){
        perror("setsockopt");
        return0;
    }
    //设置服务器地址信息设置
    server_addr.sin_family=AF_INET;                    //TCP
    server_addr.sin_port=htons(SERVER_PORT);
    server_addr.sin_addr.s_addr=INADDR_ANY;            //本地IP地址    
    memset(server_addr.sin_zero,‘\0‘,sizeof(server_addr.sin_zero));
    
    //绑定套接字与地址信息if(bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr))==-1){
        perror("setsockopt");
        return0;
    }
    
    //侦听if(listen(server_socket,5)==-1){
        perror("setsockopt");
        return0;
    }
    
    printf("listen port : %d\n",SERVER_PORT);
    
    fd_set clientfdset;
    int maxsock;
    struct timeval tv;
    
    conn_num=0;
    sin_size=sizeof(client_addr);
    maxsock=server_socket;
    
    while(1){
        //初始化，清空并添加服务器套接字到集合
        FD_ZERO(&clientfdset);
        FD_SET(server_socket,&clientfdset);
        
        //设置超时时间
        tv.tv_sec=15;
        tv.tv_usec=0;
        
        //添加连接的客户端到集合for(i=0;i<QUEUE_LENGTH;i++){
            if(client_socket[i]!=0)
                FD_SET(client_socket[i],&clientfdset);
        }
        //select模式
        ret=select(maxsock+1,&clientfdset,NULL,NULL,&tv);
        if(ret<0){
            perror("select");
            break;
        }
        elseif(ret==0){
            printf("waiting timeout\n");
            continue;
        }
        
        //检查集合内是否已经存在for(i=0;i<conn_num;i++){
            if(FD_ISSET(client_socket[i],&clientfdset)){
                ret=recv(client_socket[i],buf,sizeof(buf),0);
                
                if(ret<=0){
                    printf("client[%d] close\n",i);
                    close(client_socket[i]);
                    FD_CLR(client_socket[i],&clientfdset);
                    client_socket[i]=0;
                }
                else{
                    printf("client[%d] msg: %s\n",i,buf);
                    send(client_socket[i],buf,sizeof(buf),0);
                }
            }
        }
        
        if(FD_ISSET(server_socket,&clientfdset)){
            new_socket=accept(server_socket,(struct sockaddr*)&client_addr,&sin_size);
            if(new_socket<=0){
                perror("accept");
                continue;
            }
            if(conn_num<QUEUE_LENGTH){
                client_socket[conn_num++]=new_socket;
                printf("new client[%d] %s: %d\n",conn_num,inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                if(new_socket>maxsock)
                    maxsock=new_socket;
            }
            else{
                send(new_socket,"sorry overload!",sizeof("sorry overload!"),0);
                close(new_socket);
                break;
            }
        }
    }
    
    for(i=0;i<QUEUE_LENGTH;i++){
        if(client_socket[i]!=0)
            close(client_socket[i]);
    }
    
}

原始套接字技术：

　　原始套接字是一种套接字底层技术，它工作在网络层。利用原始套接字可以完成如下功能。

　　设置网卡为混杂模式，嗅探当前网路流经本网卡的所有数据包。
　　构造各种数据包（IP，ICMP，TCP，UDP等），并进行发送。
　　进行新协议的验证。

　　原始套接字可用于木马中的通信模块，伪造IP地址，拒绝服务攻击，数据包嗅探。

原始套接字的创建：

技术分享

数据发送：

　　在原始套接字中，执行数据发送前要条用setsocketopt函数进行套接字的首部设定：

            int
             opt;
setsockopt(sockfd,IPPROTO_IP, IP_HDRINCL, &opt, sizeof(opt));

例子：

            //
            利用原始套接字实现一个简单的采集网络数据包，并进行反向解析IP，MAC地址
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <linux/if_ether.h>
#include <linux/in.h>

#define BUFFER_MAX 2048

int main(int argc, char **argv)
{
    int rawsock;
    char buffer[BUFFER_MAX];
    char *ethhead;
    char *iphead;
    char *phead;
    
    //创建原始套接字if((rawsock=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_IP)))<0){
        printf("error:create raw socket!\n");
        exit(0);
    }
    
    long framecount =0;
    
    while(1){
        int readnum = recvfrom(rawsock,buffer,2048,0,NULL,NULL);
        
        if(readnum<42){
            printf("error:header is incomplete!\n");
            exit(0);
        }
        
        ethhead=(char*)buffer;
        phead=ethhead;
        int ethernetmask=0XFF;
        framecount++;
        
        printf("---------------AnalysisiPacket[%d]---------------\n",framecount);
        printf("MAC:");
        int i=6;
        for(;i<=11;i++)
            printf("%.2X:",phead[i]&ethernetmask);
        printf("------->");
        for(i=0;i<=5;i++)
            printf("%.2X:",phead[i]&ethernetmask);
        printf("\n");
        
        iphead=ethhead+14;
        phead=iphead+12;
        
        printf("IP:");
        for(i=0;i<=3;i++){
            printf("%d",phead[i]&ethernetmask);
            if(i!=3)
                printf(".");
        }
        printf("------->");
        for(i=4;i<=7;i++){
            printf("%d",phead[i]&ethernetmask);
            if(i!=7)
                printf(".");
        }
        printf("\n");
        
        int prototype=(iphead+9)[0];
        phead=iphead+20;
        
        printf("Protocol:");
        switch(prototype){
        case IPPROTO_ICMP:
            printf("ICMP\n");
            break;
        case IPPROTO_IGMP:
            printf("IGMP\n");
            break;
        case IPPROTO_IPIP:
            printf("IP");
            break;
        case IPPROTO_TCP:
            printf("TCP|source port: %u |",(phead[0]<<8)&0XFF00|phead[1]&0XFF);
            printf("destport: %u\n",(phead[2]<<8)&0XFF00|phead[3]&0XFF);
            break;
        case IPPROTO_UDP:
            printf("UDP|source port: %u |",(phead[0]<<8)&0XFF00|phead[1]&0XFF);
            printf("destport: %u\n",(phead[2]<<8)&0XFF00|phead[3]&0XFF);
            break;
        case IPPROTO_RAW:
            printf("RAW\n");
            break;
        default:
            printf("Unkown\n");    
        }
        printf("-----------------end--------------------");
    }
    
    return0;
}

广播技术：

　　ARP（Address Resolution Protocol）和NTP（Network Time Protocol）都属于广播通信。

　 ARP是局域网中的地址解析协议，利用这个协议，可以找出IP地址到MAC地址的映射关系。当主机A准备与主机B通信时，如果只知道主机B的IP地址，则主机A向整个全网发送一个ARP请求，询问IP地址为XXXX的主机，如果主机B收到就会产生回应。

　　NTP是网络时间协议。在支持广播的局域网中设置NTP协议，可以使NTP服务器每隔一个固定的时间间隔，就向全网发送时间信息，客户端在收到时间信息后进行更新处理。

原理解析：

　　要进行广播通信，首先要理解广播地址。在IP地址中，如果最后一个数字是255，则一定是一个广播地址。

网络广播地址：网络广播地址在没有进行子网划分的网络内广播，由于当强的网络均涉及子网划分，故此种地址很少存在
受限广播地址：以255.255.255.255组成的广播地址，在当前路由器均不转发此类广播
子网广播地址：子网广播地址是一种常用的广播方式，它是指在一个具体的子网内进行广播，比如192.168是网络ID，那么192.168.1.255就是子网192.168.1的广播
全部子网广播地址：是指所有子网络的广播，以上一个为例，全部子网广播地址是192.168.255.255

广播要采用UDP的方式，具体流程如下：

创建UDP套接字
设置套接字属性为SO_BROADCAST，设置为广播地址
设置广播地址为INADDR_BROADCAST，同时也要指定发送端口
进行数据收发操作

例子：

            //
            bserver.c
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>

#define BUFFSIZE 200
#define PORT 5050

int main(int argc, char **argv)
{
    int serversocket;
    struct sockaddr_in serveraddress,clientaddress;
    
    int so_broadcast=1;

    
    if((serversocket=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("socket");
        return0;
    }
    
    if(setsockopt(serversocket,SOL_SOCKET,SO_BROADCAST,&so_broadcast,sizeof(so_broadcast))<0){
        perror("setsockopt");
        return0;
    }
    
    serveraddress.sin_family=AF_INET;
    serveraddress.sin_port=htons(INADDR_ANY);
    serveraddress.sin_addr.s_addr=htonl(INADDR_BROADCAST);
    
    if(bind(serversocket,(struct sockaddr*)&serveraddress,sizeof(struct sockaddr))<0){
        perror("bind");
        return0;
    }
    
    clientaddress.sin_family=AF_INET;
    clientaddress.sin_port=htons(PORT);
    clientaddress.sin_addr.s_addr=htonl(INADDR_BROADCAST);
    
    while(1){
        char buf[BUFFSIZE];
        printf("please input your word:");
        scanf("%s",buf);
        if(sendto(serversocket,buf,strlen(buf),0,(struct sockaddr*)&clientaddress,sizeof(clientaddress))<0){
            perror("sendto");
            return0;
        }
        else
            printf("send msg: %s\n",buf);
    }
    
    return0;
}

            //
            bclient.c
#include <sys/types.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int clientsocket;
    struct sockaddr_in serveraddress,clientaddress;
    
    clientsocket=socket(AF_INET,SOCK_DGRAM,0);
    
    serveraddress.sin_family=AF_INET;
    serveraddress.sin_port=htons(5050);
    serveraddress.sin_addr.s_addr=htonl(INADDR_ANY);
    
    int opt=1;
    if(setsockopt(clientsocket,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0){
        perror("setsockopt");
        return0;
    }
    
    if(bind(clientsocket,(struct sockaddr*)&serveraddress,sizeof(struct sockaddr))!=0){
        perror("bind");
        return0;
    }
    
    char buf[200];
    
    while(1){
        memset(buf,0,200);
        int size=0;
        size=recvfrom(clientsocket,buf,200,0,(struct sockaddr*)&serveraddress,sizeof(serveraddress));
        buf[size]=‘\0‘;
        printf("IP:%s msg:%s\n",inet_ntoa(clientaddress.sin_addr),buf);
        
        if(strcmp(buf,"quit")==0){
            printf("system quit!\n");
            close(clientsocket);
            return0;
        }
    }
    
    return0;
}

组播技术：

　　组播可以实现小范围内的互联，在发送者和每一个接受者之间时间点对多点的网络连接，是广播通信的一种变种。

　　根据IP地址的规定，D类地址为组播地址，其网络号为固定的1110,第4到31位定义了某一特殊的组播地址，范围为244.0.0.0～239.255.255.255。其中244.0.0.0～244.0.0.255的地址，它们大多是为了特殊的目的保留的，不建议使用。

套接字的基本属性：组播参数对应5个参数，通过setsockopt设置

            //
            加入组播
            int setsockopt(client_socket,IPPROTO_IP,IP_ADD_MEMBERSHIP,&multiaddress,sizeof(multiaddress))

//退出组播int setsockopt(client_socket,IPPROTO_IP,IP_DROP_MEMBERSHIP,&multiaddress,sizeof(multiaddress))

//这里有一个重要的参数multiaddress，结构：struct ip_mreq{
    struct in_addr imr_multiaddr;        //组播地址struct in_addr imr_interface;          //IPv4地址
}

主要流程：

服务器端设置一个多播地址，创建一个多播组。
客户端指定多播地址，加入多播。
程序结束后，退出多播。

例子：

            //
            memberServer.c
            
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    int server_socket;
    struct sockaddr_in address;
    
    //创建UDP
    server_socket=socket(AF_INET,SOCK_DGRAM,0);
    if(server_socket<0){
        perror("socket");
        return0;
    }
    
    //初始化多播地址
    memset(&address,0,sizeof(address));
    address.sin_family=AF_INET;
    address.sin_port=htons(5555);
    address.sin_addr.s_addr=inet_addr("224.0.1.100");
    
    //发送信息while(1){
        char buf[200];
        printf("input your word:");
        scanf("%s",buf);
        if(sendto(server_socket,buf,sizeof(buf),0,(struct sockaddr*)&address,sizeof(address))<0){
            perror("sendto");
            return0;
        }
    }
    
    return0;
}

            //
            memberClient.c
            
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    struct ip_mreq mreq;
    int serveraddress_len;
    int client_socket;
    struct sockaddr_in serveraddress;
    
    //初始化地址
    memset(&serveraddress,0,sizeof(serveraddress));
    serveraddress.sin_family=AF_INET;
    serveraddress.sin_port=htons(5555);
    serveraddress.sin_addr.s_addr=htonl(INADDR_ANY);
    
    if((client_socket=socket(AF_INET,SOCK_DGRAM,0))<0){
        perror("client");
        return0;
    }
    
    //绑定SOCKETif(bind(client_socket,(struct sockaddr*)&serveraddress,sizeof(serveraddress))<0){
        printf("bind");
        return0;
    }
    
    int opt=1;
    if(setsockopt(client_socket,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0){
        printf("setsockopt1");
        return0;
    }
    
    //加入多播
    mreq.imr_multiaddr.s_addr=inet_addr("244.0.1.100");
    mreq.imr_interface.s_addr=htonl(INADDR_ANY);
    
    if(setsockopt(client_socket,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq))<0){
        perror("setsockopt2");
        return0;
    }
    
    while(1){
        char buf[200];
        serveraddress_len=sizeof(serveraddress);
        if(recvfrom(client_socket,buf,200,0,(struct sockaddr*)&serveraddress,(socklen_t *)serveraddress_len)<0){
            perror("recvfrom");
        }
        printf("msg from server: %s\n",buf);
        
        if(strcmp(buf,"quit")==0){
            if(setsockopt(client_socket,IPPROTO_IP,IP_DROP_MEMBERSHIP,&mreq,sizeof(mreq))<0){
                perror("setsokopt3");
            }
            close(client_socket);
            return0;
        }
    }
    
    return0;
}

原文：http://www.cnblogs.com/yorkyang/p/7804627.html

内容总结

以上是互联网集市为您收集整理的linux 高级网络编程全部内容，希望文章能够帮你解决linux 高级网络编程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1284422.html

来源：【匿名】

【上一篇】linux下docker操作记录【下一篇】Linux下安装GD

更多 ►

【linux 高级网络编程】教程文章相关的互联网学习教程文章

转自：http://www.cnblogs.com/coder2012/archive/2013/03/31/2991785.html设置套接字函数：#include<sys/socket.h>int setsockopt(int sockfd, int level, int optname, constvoid* optval, socklen_t* optlen);//sockfd要设置的目的套接字 //level套接字的控制层次 //optname optval optlen是三个相关的参数，通过不同的搭配可以设置不同的功能应用：1.数据收发时限设置struct timeva timeout; timeout.tv_sec=5; timeout.tv_use...

Linux网络编程初步【代码】

目录Linux网络编程初步主机字节序和网络字节序一个网络编程的例子Linux网络编程初步主机字节序和网络字节序32位置机器一次性能装载4字节。那么四字节在内存的顺序影响它被累加器装载成的整数的值。主要分为大端和小端。大端字节序是一个整数高位字节(23~31bit)存在内存的低处，低字节(0~7 bit) 存储在内存的高地址处。小端相反。现代PC大多是小端序。小端就称为主机字节序。JVM采用大端(网络字节序)。下面是检测大端小段的案例我的...

Linux 网络编程的5种IO模型【代码】【图】

五种IO模型详解? 转载绿色藤蔓最后发布于2018-03-20 11:26:52 阅读数 2853 收藏? 展开在《Unix网络编程》一书中提到了五种IO模型，分别是：阻塞IO、非阻塞IO、多路复用IO、信号驱动IO以及异步IO。下面就分别来介绍一下这5种IO模型的异同。1.阻塞IO模型　　最传统的一种IO模型，即在读写数据过程中会发生阻塞现象。　　当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞...

Linux 网络编程——UDP编程【图】

概述UDP 是 User Datagram Protocol 的简称，中文名是用户数据报协议，是一个简单的面向数据报的运输层协议，在网络中用于处理数据包，是一种无连接的协议。UDP不提供可靠性的传输，它只是把应用程序传给 IP 层的数据报发送出去，但是并不能保证它们能到达目的地。由于 UDP 在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。UDP 有如下的特点：1）邮件系统服务模式的抽象（可通过邮件...

Linux 网络编程高级套接字【代码】【图】

一、套接字选项：有以下3中方式可以对套接字选项进行设置：getsockopt 和 setsockopt 函数fcntl函数ioctl函数getsockopt和setsockopt函数用于获得和设置套接字的选项值，fcntl用来操作文件描述符的有关属性，比如设置套接字文件描述符工作于非阻塞模式等，而ioctl用于控制I/O设备。套接字选项和协议层协议层(Level) 选项(optname)含义SOL_SOCKET (套接字通用选项) SO_KEEPALIVE O_RESUSEADDR ...

UNIX/Linux网络编程基础：图解TCP/IP协议栈【图】

目录1、主机到网络层协议：以太网协议2、IP协议3、网际控制报文协议（ICMP）4、传输控制协议（TCP）5、用户数据报文协议（UDP）6、地址解析协议ARP 联网的各个终端之间能否进行交互的软件基础是网络协议栈，目前主流的网络协议栈是TCP/IP协议栈。1、主机到网络层协议：以太网协议主机到网络层主要为IP协议和ARP协议提供服务、发送和接收网络数据报。本层中由于要实现跨网和跨设备的互通，有很多的实现方式，这里我们只关注以太网的...

Linux网络编程--多线程实现echo服务器与客户端“一对多”功能，是网络编程的“Hello World!”【代码】【图】

在linux平台下，用多线程实现echo服务器与客户端“一对多”（即是一台服务器可以响应多个客户端的请求）。本人写了个demo，和大家一起分享，有不足的地方，请多多指教，我是壮壮熊。　　编译时，在后面加上-lpthread。例如：g++ service2.cpp -o service2 -lpthread。否则会提示线程方面的错误。echo服务器端代码： 1 #include<stdio.h>2 #include<stdlib.h>3 #include<sys/socket.h>4 #include<string.h>5 #include<errno.h>6...

【Linux 网络编程】常用TCP/IP网络编程函数【代码】

(1)函数socket 1/****************************************************************2** 功能：创建一个套接字用于通信3** 参数：domain 指定通信协议族4** type 指定socket类型，流式套接字 SOCK_STREAM 5** 数据报套接字 SOCKDGRAM6** 原始套接字 SOCKRAW7** protocol 协议类型 (习惯上填写0)8** 返回值：成功返回非负整数，它与文件描述符类似，...

【linux高级程序设计】（第十三章）Linux Socket网络编程基础【代码】【图】

IP地址定义：struct in_addr{__u32 s_addr; }; in_addr_t inet_addr (__const char * __cp) ：把点分十进制IP地址字符串转换为32位IP地址（网络存储顺序）。in_addr_t inet_network (__const char * __cp) ：把点分十进制IP地址字符串转换为32位IP地址（主机字节顺序）。char * inet_ntoa (struct in_addr_in) ：把32位网络字节顺序的IP地址转换成点分十进制表示。int inet_aton (__const char *__cp, struct in_addr *__inp) ：把...

服务器编程入门（4）Linux网络编程基础API【图】

在Java中执行脚本命令以及调用外部程序说明一、Java中关于ProcessBuilder 和 Runtime 类的介绍在Java中要想执行脚本或者调用程序必须通过ProcessBuilder 和 Runtime 类，以上两个类任选一个就行，关于他们的介绍如下：ProcessBuilder.start() 和 Runtime.exec() 方法都被用来创建一个操作系统进程（执行命令行操作），并返回Process 子类的一个实例，该实例可用来控制进程状态并获得相关信息。Process 类提供了执行从进程输入、执行...

linux网络编程之TCP/IP基础篇（一）【图】

从今天起，将会接触到网络编程，平台是linux，实现语言C语言，最后将会实现一个简易的miniftp服务器。　　主要的内容安排为：linux网络编程之TCP/IP基础篇，SOCKET编程篇，进程间通信篇，线程篇，实战ftp篇。　　1.ISO/OSI参考模型：open system interconnection开放系统互联模型是由OSI（international organization for standardization ）国际标准化组织定义的网络分层模型，共七层。　　各层的具体含义：　　物理层（Physical ...

Linux网络编程——tcp并发服务器（多线程）【图】

tcp多线程并发服务器多线程服务器是对多进程服务器的改进，由于多进程服务器在创建进程时要消耗较大的系统资源，所以用线程来取代进程，这样服务处理程序可以较快的创建。据统计，创建线程与创建进程要快 10100 倍，所以又把线程称为“轻量级”进程。线程与进程不同的是：一个进程内的所有线程共享相同的全局内存、全局变量等信息，这种机制又带来了同步问题。tcp多线程并发服务器框架:我们在使用多线程并发服务器时，直接使用以上...

linux socket网络编程详解【图】

一、系统调用和应用编程接口在讨论网络通信之前，首先明确两个概念：系统调用（system call）和应用编程接口（ApplicationProgramming Interface，API）。操作系统使用系统调用机制来实现在应用程序与操作系统之间进行控制权传递。当某个应用进程启动了系统调用时，控制权就从应用程序传递给操作系统。操作系统执行某个内部过程之后，把控制权返回给应用程序。对程序员来说，每一个系统调用和一般程序设计中的函数调用非常...

linux网络编程----->线程同步-->信号量【代码】

开发使用多线程过程中, 不可避免的会出现多个线程同时操作同一块共享资源, 当操作全部为读时, 不会出现未知结果, 一旦当某个线程操作中有写操作时, 就会出现数据不同步的事件. 而出现数据混乱的原因:资源共享(独享资源则不会)调试随机(对数据的访问会出现竞争)线程间缺少必要的同步机制以上三点, 前两点不能被改变. 欲提高效率, 传递数据, 资源必须共享. 只要资源共享, 就一定会出现线程间资源竞争, 只要存在竞争关系, ...

linux网络编程实例【代码】【图】

获取服务器时间#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h>#define HOSTNAMELEN 40 #define BUFLEN 1024 #define PORT 13int main(int argc, char *argv[]) {int rc;int sockfd;char buf[BUFLEN+1];char *pc;struct sockaddr_in sa;struct hostent *hen;if (argc < 2) {...

LINUX - 最热教程

Xrdp - 通过Windows的RDP连接Linux远程...VMware中Linux虚拟机挂载主机共享文件夹...Linux双网卡配置虚拟机下Linux安装好Nginx后，宿主机无...linux下安装postgresql并配置远程图形桌...Linux命令--exportfs命令详解 linux 终端printf打印显示乱码问题修正 Linux下Shell的for循环语句N种写法 Linux下创建nginx脚本-start、stop、re...SUSELinux安装MySQL