linux socket程序源代码(本地与网络)

最新推荐文章于 2025-08-12 20:35:18 发布
最新推荐文章于 2025-08-12 20:35:18 发布
阅读量731 收藏 1
点赞数
分类专栏： linux 文章标签： socket 网络 linux struct server unix

1、端口号是用来区分用户程序的。

2、其实，只要撑握了UNIX域的编程，那么网络编程就显得简单了。

3、UNIX域：UDP  和  TCP

      网络：      UDP  和  TCP

4、下面是相关的例程：

一、首先是UNIX域的编程：

1、C

/*UNIX域：UDP_client*/ 
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PATHNAME "/tmp/socket"
#define CLIENTPATH "/tmp/socket_1"
struct student {
    char name[20];
    double avg;
};

int main(int argc, char **argv)
{
    if (argc != 3) {
        fprintf(stderr, "Usage.../n");
        exit(1);
    }

    int ret, sd;
    struct sockaddr_un server_addr, client_addr;
    socklen_t server_len, client_len;
     struct student buf;

    server_addr.sun_family = AF_UNIX;
    client_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, PATHNAME, 108);    
    strncpy(client_addr.sun_path, CLIENTPATH, 108);    
    server_len = sizeof(struct sockaddr_un);
    client_len = sizeof(struct sockaddr_un);

    sd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }
#if 1
    unlink(CLIENTPATH);
    ret = bind(sd, (struct sockaddr *)(&client_addr),//绑定自己
        client_len);
    if (ret == -1) {
        perror("bind");
        close(sd);
        exit(1);
    }
#endif

    strncpy(buf.name, argv[1], 20);
    buf.avg = atof(argv[2]);

    ret = sendto(sd, &buf, sizeof(buf), 0, 
        (struct sockaddr *)&server_addr, 
        server_len);
    if (ret == -1) {
        perror("sendto");
        close(sd);
        exit(1);
    }

    close(sd);
    exit(0);
}

1、S

/*UNIX域：UDP_server*/ 
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PATHNAME "/tmp/socket" 
struct student {
    char name[20];
    double avg;
};

int main(void)
{
    int ret, sd;
    struct sockaddr_un server_addr, client_addr;
    socklen_t server_len, client_len;
     struct student buf;

    server_addr.sun_family = AF_UNIX;//sun_family always contains AF_UNIX
    strncpy(server_addr.sun_path, PATHNAME, 108);    
    server_len = sizeof(struct sockaddr_un);
    client_len = sizeof(struct sockaddr_un);//这一步也需要

    sd = socket(AF_UNIX, SOCK_DGRAM, 0);//UDP
    if (sd == -1) {
        perror("socket");
        exit(1);
    }
    unlink(PATHNAME);//在绑定之前，如果此PATHNAME已存在，则删除,确保绑定成功。
    ret = bind(sd, (struct sockaddr *)(&server_addr),//第二个参数别忘了强制转换成(struct sockaddr *)
        server_len);
    if (ret == -1) {
        perror("bind");
        close(sd);
        exit(1);
    }

    while (1) {//recvfrom在没数据时也会阻塞
        ret = recvfrom(sd, &buf, sizeof(buf), 0, 
            (struct sockaddr *)&client_addr, 
            &client_len);
//如果不关心client的地址，则可写成recvfrom(sd,&buf,sizeof(buf),0,NULL,NULL);
        if (ret == -1) {
            perror("recvfrom");
            close(sd);
            exit(1);
        }
        if (ret > 0) {
            printf("name=%s/n", buf.name);
            printf("average point=%f/n", 
                buf.avg);
            printf("Infomation from %s/n",
                client_addr.sun_path);
        }

    }

    close(sd);
    exit(0);
}

2、comm.h

comm.h

#ifndef __COMM__H
#define __COMM__H

struct student {
    int length;
    int chinese;
    int math;
    char name[1];
};

#define CLIENTPATH "/tmp/client"
#define SERVERPATH "/tmp/server"
#endif

2、C

/*偷看数据包：UDP_client*/ 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <string.h>
#include "comm.h"

int main(int argc, char **argv)
{
    if (argc != 2) {
        printf("Usage...");
        exit(1);
    }

    int sd, ret, length;
    struct sockaddr_un addr;
    socklen_t len = sizeof(addr);
    struct student *buf;
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SERVERPATH, 108);

    sd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }

    length = sizeof(struct student) + strlen(argv[1]);//这是扩展后的长度。因为argv[1]的长度是不定的，所以需要扩展
    buf = (struct student *)calloc(length, 1);
    buf->length = length;
    buf->chinese = 99;
    buf->math = 87;
    strncpy(buf->name, argv[1], strlen(argv[1]));

    ret = sendto(sd, buf, length, 0, 
            (struct sockaddr *)&addr, 
            len);
    if (ret == -1) {
        perror("sendto");
        exit(1);
    }
    close(sd);
    exit(0);
}
/*
 1、变长数组：struct student {
    int length;
    int chinese;
    int math;
    char name[1];
};
name放在最后，以便于扩展。结构体是给编译器看的，是骗子。
char name[1]有用的是一个地址。
 2、

*/

2、S
/*偷看数据包：UDP_server*/ 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <string.h>
#include "comm.h"

int main(void)
{
    int sd, ret, length;
    struct sockaddr_un addr;
    socklen_t len = sizeof(addr);
    struct student peekbuf, *ptr;
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SERVERPATH, 108);

    sd = socket(AF_UNIX, SOCK_DGRAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }
    
    unlink(SERVERPATH);
    ret = bind(sd, (struct sockaddr *)&addr,
        len);
    if (ret == -1) {
        perror("bind");
        close(sd);
        exit(1);
    }

    while (1) {
        ret = recvfrom(sd, &peekbuf, 
            sizeof(peekbuf), MSG_PEEK, 
            NULL, NULL);//先偷看一下数据包
        if (ret == -1) {
            perror("recvfrom");
            exit(1);
        }
        if (peekbuf.length > 0) {
            length = peekbuf.length;
            ptr = (struct student *)calloc(
                length, 1);
            if (NULL == ptr) {
                perror("calloc");
                continue;
            }
            ret = recvfrom(sd, ptr, length, 0,
                NULL, NULL);//偷看后，没问题就取走数据包
            if (ret == -1) {
                perror("recvfrom");
                exit(1);
            }
            printf("name=%s/n", ptr->name);
            printf("math=%d/nchinese=%d/n",
                ptr->math, ptr->chinese);
            if (ptr) {
                free(ptr);//别忘了free
                ptr = NULL;
            }
        } 
    }

    close(sd);
    exit(0);
}
/*
 1、偷看，只是先尝试着读数据，但它不会将数据从缓冲区取走
 2、MSG_PEEK偷看(recvfrom的第四个参数)
 3、写成NULL==ptr是因为怕写成了ptr=NULL
*/

3、C

/ *UNIX域：TCP_client*/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/un.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>

#define SERVERPATH "/tmp/server"


int main(void)
{
    int sd, newsd, ret;
    struct sockaddr_un addr;
    socklen_t length;
    char buf[100];    

    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SERVERPATH, 108);
    length = sizeof(addr);    

    sd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }

    ret = connect(sd, (struct sockaddr *)&addr, //连接到服务器
        length);
    if (ret == -1) {
        perror("connect");
        exit(1);
    }

    while (1) {
        ret = read(sd, buf, 100);
        if (ret == -1) {
            perror("read");
            exit(1);
        }
        if (ret == 0)
            break;
        write(1, buf, ret);
    
    }
    close(sd);
    exit(0);
}

3、S

/*UNIX域：TCP_server*/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/un.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>

#define SERVERPATH "/tmp/server"

int processConnect(int newsd, int sd)
{
    pid_t pid;
    
    pid = fork();
    if (pid == -1) {
        perror("fork");
        return pid;
    }
    if (pid == 0) {
        close(sd);//别忘了关闭子进程的老sd
        char buf[100];
        int fd, ret;

        fd = open("/etc/passwd", O_RDONLY);
        if (fd == -1) {
            perror("open");
            return fd;
        }
        while (1) {
            ret = read(fd, buf, 100);
            if (ret == -1) {
                perror("read");
                return -1;
            }
            if (ret == 0) {
                break;
            }
            write(newsd, buf, ret);
        }
        close(newsd);
        close(fd);
        exit(0);
    }
    return 0;
}

int main(void)
{
    int sd, newsd, ret;
    struct sockaddr_un addr;
    socklen_t length;

    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SERVERPATH, 108);
    length = sizeof(addr);    

    sd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }

    unlink(SERVERPATH);
    ret = bind(sd, (struct sockaddr *)&addr,//UNIX域要绑定才能实现双向通信!!
        length);
    if (ret == -1) {
        perror("bind");
        exit(1);
    }

    ret = listen(sd, 10);//只是标志socket处于监听，不会在listen这阻塞
    if (ret == -1) {
        perror("listen");
        exit(1);
    }

    while (1) {//队列不为空时，accept返回一个新的套接字，专门用于交流；老的套接字继续监听，不受新的影响
        newsd = accept(sd, NULL, NULL);//如果不关心请求方是谁的话，后两个参数写NULL就行
        if (newsd == -1) {
            perror("accept");
            exit(1);
        }
        ret = processConnect(newsd, sd);
        if (ret == -1) {
            close(sd);
            close(newsd);
            exit(1);
        }
        close(newsd);
    }
    close(sd);
    exit(0);
}
/*
 1、TCP，流的套接字，字节流(双向)
 2、
SERVER      CLIENT
socket      socket
bind        可bind可不bind
listen      connect
accept    
 3、listen只是标志socket处于监听，不会在listen这阻塞
 4、会在accept阻塞，队列不为空时，accept返回一个新的套接字(newsd)，专门用于交流；老的套接字继续监听，不受新的影响
 5、accept，如果不关心请求方是谁的话，后两个参数写NULL就行
 6、accept位于死循环里
 7、fork一个子进程后，因为继承了很多东西，例如sd。但是如果子进程不用老sd，那么要关闭它
*/

再来看网络：

1、C

/*网络INET: UDP_client*/ 
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>

#define SERVERPORT 6789
#define CLIENTPORT 8989

struct student {
    char name[20];
    float avg;
};

int main(void)
{
    int ret, sd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t server_len, client_len;
     struct student buf;
    struct pollfd event[2];
    char rep[32];

    server_addr.sin_family = AF_INET;
    client_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVERPORT);    
    client_addr.sin_port = htons(CLIENTPORT);    
    inet_pton(AF_INET, "192.168.240.131", 
        &server_addr.sin_addr);
    inet_pton(AF_INET, "192.168.240.131", 
        &client_addr.sin_addr);
    
    server_len = sizeof(struct sockaddr_in);
    client_len = sizeof(struct sockaddr_in);

    sd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }
#if 0
    ret = bind(sd, (struct sockaddr *)(&client_addr),
        client_len);
    if (ret == -1) {
        perror("bind");
        close(sd);
        exit(1);
    }
#endif
    event[0].fd = 0;
    event[0].events = POLLIN;
    event[1].fd = sd;
    event[1].events = POLLIN;
    while (1) {
        write(1, "Please input name and score:/n", 
            29);
POLL:
        ret = poll(event, 2, -1);
        if (ret == -1) {
            perror("poll");
            exit(1);
        }
        if (event[0].revents & POLLIN) {
            scanf("%s %f", buf.name, &buf.avg);
            buf.avg = htonl(buf.avg);
            ret = sendto(sd, &buf, sizeof(buf),0, (struct sockaddr *)&server_addr,server_len);
            if (ret == -1) {
                perror("sendto");
                close(sd);
                exit(1);
            }
            goto POLL;
        }
        if (event[1].revents & POLLIN) {
            ret = recvfrom(sd, rep, 32, 0,
                NULL, NULL);
            if (ret == -1) {
                perror("recvfrom");
                exit(1);
            }
            printf("Jugement:%s/n", rep);
        }
    }
    close(sd);
    exit(0);
}
/*
 1、网络走“大端”
 2、htons()：将一个16位数从主机字节序转换成网络字节序。
　　返回值：htons()返回一个网络字节序的值。
   同类函数有：ntohs(),htonl(), ntohl().
 3、Linux下2个IP地址转换函数，可以在将IP地址在“点分十进制”和“整数”之间转换 :
   inet_pton:点分十进制转换成整数，inet_ntop:整数转换成点分十进制
 4、网络：server要绑定,但client绑不绑定都可以，因为会随机给你选一个端口，以实现双向通信。
   而本地UNIX域：client如果不绑定的活就不能实现双向通信

*/

1、S

/*网络INET: UDP_server*/ 
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SERVERPORT 6789

struct student {
    char name[20];
    float avg;
};

int main(void)
{
    int ret, sd;
    char rep[32];

    struct sockaddr_in server_addr, client_addr;
    socklen_t server_len, client_len;
     struct student buf;
    char ipbuf[16];//用于存ip地址.大小为16!记住

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVERPORT);
    inet_pton(AF_INET, "192.168.240.131", 
        &server_addr.sin_addr);

    server_len = sizeof(struct sockaddr_in);
    client_len = sizeof(struct sockaddr_in);

    //daemon(0, 0);
    sd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }
    ret = bind(sd, (struct sockaddr *)(&server_addr),
        server_len);
    if (ret == -1) {
        perror("bind");
        close(sd);
        exit(1);
    }

    while (1) {
        ret = recvfrom(sd, &buf, sizeof(buf), 0, 
            (struct sockaddr *)&client_addr, 
            &client_len);
        if (ret == -1) {
            perror("recvfrom");
            close(sd);
            exit(1);
        }
        if (ret > 0) {
            buf.avg = ntohl(buf.avg);
            printf("name=%s/n", buf.name);
            printf("average point=%f/n", 
                buf.avg);
            printf("client ip address:%s/n", 
                inet_ntop(AF_INET, 
                    &client_addr.sin_addr,
                    ipbuf, 16));
            printf("client port:%d/n", 
                ntohs(client_addr.sin_port));
        }
        if (buf.avg -60.0 >= 0.0) {
            strncpy(rep, "Good", 32);
        } else
            strncpy(rep, "Bad", 32);
        ret = sendto(sd, &rep, 32, 0,
            (struct sockaddr *)&client_addr, 
            client_len);
        
        if (ret == -1) {
            perror("sendto");
            close(sd);
            exit(1);
        }
    }

    close(sd);
    exit(0);
}
/*1、网络与本地UNIX域最大的区别就是sockaddr的构造不同
  2、发送端：htonl
     接收端：ntohl
  3、UDP发的是包，用到两个函数：sendto,recvfrom
   而TCP字节流操作。不用sendto和recvfrom，而是直接对一个套接字操作。
*/

2、C

/*网络INET: TCP_client*//*聊天*/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <poll.h>
#include <unistd.h>

#define SERVERPATH "192.168.0.237"
#define CLIENTPATH "192.168.0.237"
#define SERVERPORT 1234
#define CLIENTPORT 5678

struct pollfd fds[2];
void poll_init(int sd)
{
    fds[0].fd=0;
    fds[0].events=POLLIN;
    fds[1].fd=sd;
    fds[1].events=POLLIN;
}
int main(void)
{
    int sd,ret,i,j;
    char buf[100];
    char writebuf[100];
    struct sockaddr_in server_addr,client_addr;
    socklen_t server_len,client_len;

    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SERVERPORT);
    inet_pton(AF_INET,SERVERPATH,&server_addr.sin_addr);
    client_addr.sin_family=AF_INET;
    client_addr.sin_port=htons(CLIENTPORT);
    inet_pton(AF_INET,CLIENTPATH,&client_addr.sin_addr);
    server_len=sizeof(struct sockaddr_in);
    client_len=sizeof(struct sockaddr_in);

    sd=socket(AF_INET,SOCK_STREAM,0);
    if(sd==-1)
    {
        perror("socket");
        exit(1);
    }
#if 0
    ret=bind(sd,(struct sockaddr *)&client_addr,client_len);
    if(ret==-1)
    {
        perror("bind");
        exit(1);
    }
#endif
    ret=connect(sd,(struct sockaddr *)&server_addr,server_len);
    if(ret==-1)
    {
        perror("connect");
        exit(1);
    }

    poll_init(sd);
    while(1)
    {
        printf("come in big while!/n");
        ret=poll(fds,2,-1);
        if(ret==-1)
        {
            perror("poll");
            exit(1);
        }
        if(ret>0)
        {
            if(fds[0].revents & POLLIN)
            {
                i=read(0,writebuf,100);
                if(i==-1)
                {
                    perror("read");
                    exit(1);
                }
                write(sd,writebuf,i);
                printf("client write over!/n");
                continue;
            }
            if(fds[1].revents & POLLIN)
            {
                printf("come in fds[1]/n");//如果server退出了，即写端关闭，能读到文件尾。程序会不停地进来这里来。网络两端如果都不关闭，那么是读不到文件尾的，除非一方已关闭
                while(1)
                {
                    bzero(buf,100);
                    j=read(sd,buf,100);
                    if(j==-1)
                    {
                        perror("read");
                        exit(1);
                    }
                    write(1,buf,j);
                    if(j<100)
                    {
                        printf("client read over/n");
                        break;
                    }
                }
            }
        }
        
    }
    close(sd);
    exit(0);

}
/* 1、网络两端如果都不关闭，那么是读不到文件尾的，除非一方已关闭。
   2、一般来说，服务器是不能关闭的
 */

2、S

/*网络INET: TCP_client*//*聊天*/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <poll.h>

#define SERVERPATH "192.168.0.237"
#define CLIENTPATH "192.168.0.237"
#define SERVERPORT 1234
#define CLIENTPORT 5678

struct pollfd fds[2];

void poll_con(int newsd)
{
    fds[0].fd=0;
    fds[0].events=POLLIN;
    fds[1].fd=newsd;
    fds[1].events=POLLIN;
}
int ProcessConnect(int newsd,int sd)
{
    pid_t pid=fork();
    if(pid==-1)
    {
        perror("fork");
        return pid;
    }
    if(pid==0)
    {
        close(sd);
        int ret,r,re,end;
        char buf[100];
        char writebuf[100];

//        dup2(newsd,1);
        poll_con(newsd);
        write(newsd,"server readly!/n",15);
        while(1)
        {
            ret=poll(fds,2,-1);
            if(ret>0)
            {
                if(fds[0].revents & POLLIN)
                {
                    r=read(0,writebuf,100);
                    if(r==-1)
                    {
                        perror("read");
                        exit(1);
                    }
                    write(newsd,writebuf,r);
                    printf("server write over!/n");
                    continue;
                }
                
                if(fds[1].revents & POLLIN)//刚开始写成了revents!xxxx
                {
                    while(1)
                    {
                        bzero(buf,100);
                        re=read(newsd,buf,100);
                        if(re==0)
                        {
                            goto OUT;//如果能读到文件尾，也就是client已关闭，那么就退出。适当的用一下goto也无妨
                        }
                        if(re==-1)
                        {
                            perror("read");
                            exit(1);
                        }
                        write(1,buf,re);
                        if(re<100)
                        {
//                            printf("server read over!/n");
                            break;
                        }
                    }
                }
            }
        }
OUT:
        printf("client out!/n");
//        sleep(3);
        close(newsd);
        exit(0);
    }
    wait(NULL);
    return 0;
}
int main(void)
{
    int sd,newsd,ret;
    struct sockaddr_in server_addr,client_addr;
    socklen_t server_len,client_len;

    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(SERVERPORT);
    inet_pton(AF_INET,SERVERPATH,&server_addr.sin_addr);
    client_addr.sin_family=AF_INET;
    client_addr.sin_port=htons(CLIENTPORT);
    inet_pton(AF_INET,CLIENTPATH,&client_addr.sin_addr);
    server_len=sizeof(struct sockaddr_in);
    client_len=sizeof(struct sockaddr_in);

    sd=socket(AF_INET,SOCK_STREAM,0);
    if(sd==-1)
    {
        perror("socket");
        exit(1);
    }

/***************server要绑定************/
#if 1
    ret=bind(sd,(struct sockaddr *)&server_addr,server_len);
    if(ret==-1)
    {
        perror("bind");
        exit(1);
    }
#endif
    ret=listen(sd,10);
    if(ret==-1)
    {
        perror("listen");
        exit(1);
    }
    while(1)
    {
        newsd=accept(sd,NULL,NULL);
        if(newsd==-1)
        {
            perror("accept");
            exit(1);
        }
        ret=ProcessConnect(newsd,sd);
        if(ret==-1)
        {
            perror("ProcessConnect");
            exit(1);
        }
        close(newsd);

    }

}
/*
  1、本程序：来一个client，server会fork一个进程来与之对话。
  2、网络：server要绑定,但client绑不绑定都可以，因为会随机给你选一个端口，以实现双向通信。
    而本地UNIX域：client如果不绑定的活就不能实现双向通信。
  3、用goto解决一方关闭问题
*/

三、其它

1、

/*从北京气象局网站取一张图片*/ 
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 80       //80端口
#define IPADDR "210.73.64.80"  //北京气象局网站的IP

int main(int argc, char **argv)
{
    if (argc != 2) {
        printf("Usag.../n");
        exit(1);
    }

    struct sockaddr_in addr;
    int sd, fd, ret;    
    char needle[200];

    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    inet_pton(AF_INET, IPADDR, &addr.sin_addr);

    sd = socket(AF_INET, SOCK_STREAM, 0);
    if (sd == -1) {
        perror("socket");
        exit(1);
    }

    ret = connect(sd, (struct sockaddr *)&addr, 
        sizeof(addr));
    if (ret == -1) {
        perror("connect");
        exit(1);
    }

    sprintf(needle, 
        "GET /data/cloud/1010090701.JPG/r/n");
//关键在这！！！！！
    ret = write(sd, needle, strlen(needle));//写过去，告诉server你要什么了
    if (ret == -1) {
        perror("write");
        exit(1);
    }

    fd = creat(argv[1], 0666);
    if (fd == -1) {
        perror("creat");
        exit(1);
    }

    while (1) {
        ret = read(sd, needle, 200);
        if (ret == -1) {
            perror("read");
            exit(1);
        }
        if (ret == 0)
            break;
        if (ret > 0) {
            write(1, ".", 1);
            write(fd, needle, ret);
        }
    }
    close(sd);
    close(fd);
    exit(0);
}

2、

/*getaddrinfo域名解析*/ 
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>

int main(int argc, char **argv)
{
    if (argc != 2) {
        printf("Usag.../n");
        exit(1);
    }
    struct addrinfo hints;
    struct addrinfo *res, *cur;
    int ret;
    struct sockaddr_in *addr;
    char ipbuf[16];

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET;    /* Allow IPv4 */
    hints.ai_flags = AI_PASSIVE;    /* For wildcard IP address */
    hints.ai_protocol = 0;          /* Any protocol */
    hints.ai_socktype = SOCK_STREAM;
       
    ret = getaddrinfo(argv[1], NULL,
                       &hints,
                       &res);
    if (ret == -1) {
        perror("getaddrinfo");
        exit(1);
    }
    
    for (cur = res; cur != NULL; cur = cur->ai_next) {
        addr = (struct sockaddr_in *)cur->ai_addr;
        printf("%s/n", inet_ntop(AF_INET, 
            &addr->sin_addr, ipbuf, 16));
    }
    freeaddrinfo(res);
    exit(0);
}

Linux之本地Socket通信
王涛的博客
03-01 2万+
一、Sokcet 学习路径1:http://blog.youkuaiyun.com/u010073981/article/details/50734484 学习路径2:https://www.cnblogs.com/cy568searchx/p/4211124.html 学习路径3:https://www.cnblogs.com/yusenwu/p/4579167.html 为了防止资源丢失，整合如下...
linux socket通讯如何获取本地的源端口号
SweetTool的专栏
09-24 1万+
关于TCP IP网络通讯的资料非常多，TCP IP通过IP数据包模式进行端对端通讯。典型的TCP数据包如下 可以看到数据包包含了源端口号和目的端口号，客户端socket向服务端发起连接时，系统会给socket随机分配一个源端口号，我们可以通过getsocketname来获取连接成功的socket的原端口信息。
网络编程
yuhai8702的专栏
10-18 679
<br />1、端口号是用来区分用户程序的。<br />2、其实，只要撑握了UNIX域的编程，那么网络编程就显得简单了。<br />3、UNIX域：UDP  和  TCP<br />      网络：      UDP  和  TCP<br />4、下面是相关的例程：<br />一、首先是UNIX域的编程：<br />1、C<br />/*UNIX域：UDP_client*/<br /> #include <sys/socket.h><br /> #include <sys/types.h><br />
Linux C 获取主机网卡名及 IP 的几种方法
木牛的博客
08-20 850
在进行Linux时，经常会需要获取本机IP地址，除了常规的读取配置文件外，本文罗列几种个人所知的编程常用方法，仅供参考，如有错误请指出。
getaddrinfo简单应用——取得IP地址
小灰灰的专栏
07-05 2082
转自：http://blog.chinaunix.net/uid-24567872-id-87645.html     getaddrinfo提供独立于协议的名称解析 函数原型：        #include sys/types.h>        #include sys/socket.h>        #include netdb.h>
Libevent参考手册：evbuffer：缓冲IO实用功能
热门推荐
蚂蚁啃大象
10-08 1万+
libevent的evbuffer实现了为向后面添加数据和从前面移除数据而优化的字节队列。 evbuffer用于处理缓冲网络IO的“缓冲”部分。它不提供调度IO或者当IO就绪时触发IO的功能：这是bufferevent的工作。 除非特别说明，本章描述的函数都在event2/b
【Linux网络】————socket和udp协议
bhbcdxb123的博客
12-16 1794
字符串转in_addr的函数：in_addr转字符串的函数：其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
【Linux网络#2】： Socket 编程
island1314的博客
12-28 2126
📃个人主页：island1314🔥个人专栏：Linux—登神长阶⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞但是人是怎么看到聊天信息的呢?怎么执行下载任务呢?怎么浏览网页信息呢?通过启动的 qq，迅雷，浏览器。 而启动的 qq，迅雷，浏览器都是进程。换句话说，进程是人在系统中的代表，只要把数据给进程，人就相当于就拿到了数据。但是系统中，同时会存在非常多的进程，当数据到达目标主机之后，怎么转发给目标进程?这就要在网络的背景下，在系统中，标识主机的唯一性。在进行网络通信的时候，是不是
Linux C语言网络编程(学习笔记一)：socket实现本地通信
ssz__的博客
04-24 2545
Linux的网络连接是通过内核完成的，其支持多种网络协议，如TCP/IP、IPX、DDP以及IPv6等。Linux系统通过提供套接字（scoket）进行网络编程。网络程序通过socket和其他几个函数调用后返回一个通信的文件描述符，可以将这个描述符看成普通文件的描述符来操作，并通过对描述符读写操作实现网络间的数据交流。
linux本地socket通信延迟,Linux下tcp socket通信优化与问题排查
weixin_30786631的博客
05-14 2253
Linux下tcp socket通信优化与问题排查@Date 2018.12.09一. 优化1. TPC接收窗口问题 : 当TCP的接收窗口队列阻塞 -> 发送方继续发 -> 接受方丢掉 -> 发送方重传 -> 网络变糟糕解决 : 接收方把接收缓存的大小告诉发送方 -> 接收缓存满了 -> 发送方不能发送# 调大接收窗口缓存大小net.ipv4.tcp_rmem...
linux socket通讯获取本地的源端口号的实现方法
09-15
本篇文章将详细介绍如何在Linux Socket编程中获取本地源端口号。 首先，了解Socket的基本概念。Socket是操作系统提供的接口，允许应用程序利用网络协议（如TCP/IP）进行通信。创建Socket时，系统会为客户端Socket...
linux-socket-c.rar_linux socket tcp_linux 网络编程_linux网络编程_socket
09-21
在Linux系统中，Socket编程是实现网络通信的核心技术，它为开发者提供了标准接口，使得程序可以与网络服务进行数据交互。TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是两种主要的传输层...
Linux [源代码] Socket Server Client Signal 实现服务器与客户之间的交流，同时增加了信号的用法
02-27
在Linux系统中，Socket是一种进程间...通过这个示例，开发者可以了解如何在Linux环境中使用Socket进行网络编程，同时学习如何结合信号机制来控制服务器的生命周期，这对于理解和构建实际的网络服务应用程序至关重要。
W5500之“socket.c”中的相关函数
weixin_42550185的博客
08-12 371
W5500芯片Socket.c文件核心功能摘要 该文件实现了W5500网络芯片的Socket通信接口，主要功能包括： 基础功能： 提供socket()、close()等基础函数 支持TCP/UDP/MACRAW/IPRAW四种协议 管理8个Socket通道（0-7） TCP协议支持： 实现listen()服务器监听 提供connect()客户端连接 包含send()/recv()数据传输 支持disconnect()断开连接 UDP及原始套接字支持： 实现sendto()/recvfrom()数据收发处理。
下一代防火墙组网全解析
2301_79966421的博客
08-11 792
在网络安全防护中，下一代防火墙（NGAF）凭借灵活的组网能力和强大的安全特性，成为企业网络边界防护的核心设备。其多样化的部署模式、丰富的接口类型以及适配不同场景的组网方案，让它能满足从简单网络到复杂架构的各类防护需求。本文将系统梳理下一代防火墙的核心组网知识，助你全面掌握其部署与配置逻辑。
用 “故事 + 价值观” 快速建立 IP 信任感
ckjrxdn的博客
08-08 670
故事 + 价值观” 的组合，能快速缩短与用户的距离 —— 故事让 IP 从抽象符号变为可感知的存在，价值观则推动用户从被动关注转为主动认同，二者共同为变现筑牢信任基础。传递价值观需避免空洞口号，应融入具体行为：在知识输出中明确 “何为有价值的知识”，在用户互动中展现 “如何对待用户”，在商业行为中坚守 “变现与价值的平衡”。基于 “故事 + 价值观” 的信任，能降低变现阻力：情感认同转化为知识产品的尝试意愿，价值认同提升流量变现的接受度，深度信任则强化粉丝变现的复购与推荐动力。
解决H616用网络的IP地址连不上
H212202165的博客
08-12 209
先用cmd工具进行对单片机的ip地址进行ping是否存在，存在就改变wifi的网关地址。电脑的wifi网关与h616不一致，需要改变WiFi的网关。电脑是192.168.0.105。单片机是192.128.1.55。
终端安全与网络威胁防护笔记
最新发布
2403_86572967的博客
08-12 351
网关杀毒（Gateway Antivirus）是部署在网络网关设备（如防火墙、路由器、UTM 统一威胁管理设备等）上的病毒防护技术。其核心作用是在网络流量进入内部网络前，对数据进行扫描过滤，拦截恶意文件、病毒、蠕虫等威胁，阻止其渗透到内部终端或服务器。
BGP知识点整理
2401_85431745的博客
08-11 793
（1）AS_PATH：解决AS之间的环路问题（2）IBGP的水平分割：解决同一个AS内部IBGP邻居之间环路问题（3）cluster_list防环：当一个反射群中存在多个反射器时，通过cluster_list防环（4）originator_id：在多个反射群之间，通过originator_id防环注意事项：反射路由无法使用策略，只能在始发路由上更改路由属性。
Linux Socket编程核心教程与源代码解析
Linux Socket Programming（Linux 套接字编程）是一种在Linux操作系统上进行网络编程的方法，它允许在不同的进程或者不同主机上的进程之间进行通信。套接字（Socket）是计算机网络数据传输的基本构件，它可以视为一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值