socket最基础的例子——别看！

最新推荐文章于 2024-08-11 02:10:50 发布
最新推荐文章于 2024-08-11 02:10:50 发布
阅读量960 收藏 1
点赞数
分类专栏： 闲得慌
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frecon/article/details/80472578
版权

一个tcp select的socket server，注意里面对select的时候和对信号的处理：

#include <stdio.h>
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>

#include "sockComm.h"

#define MAX_LISTEN_QUEUE 5
#define RECV_BUFFER_SIZE 8
#define SELECT_TIMEOUT_ITV 5

void ouch(int sig)
{
    printf("ctrl C caught!\n");
}

/* 一个基于TCP的socket server */
int main()
{
    int serverSockfd;
    int ret = -1;
    struct sockaddr_in server_in;
    struct sockaddr_in client_in[MAX_LISTEN_QUEUE];
    int newSockfd[MAX_LISTEN_QUEUE];
    char * localIp = "192.168.43.75";
    char * recvBuf = NULL;
    int recvLen;
    int sin_size = 0;
    int i = 0;

    int opt = 1;
    fd_set fdSetRead;
    struct timeval tv = {0};

    struct sigaction sact;
    sact.sa_handler = ouch;
    sigemptyset(&sact.sa_mask); //将mask清空
    sact.sa_flags = SA_RESTART; //影响系统调用被信号中断后的走向
    //sact.sa_flags = SA_RESETHAND; //处理一次后恢复默认动作。

    sigaction(SIGINT, &sact, 0);

    tv.tv_sec = SELECT_TIMEOUT_ITV;
    tv.tv_usec = 0;

    serverSockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == serverSockfd)
    {
        SOCK_ERR("create client socket error");
        return -1;
    }

    server_in.sin_family = AF_INET;
    server_in.sin_port = htons(6603);
    server_in.sin_addr.s_addr = inet_addr(localIp);
    memset(&server_in.sin_zero, 0, sizeof(server_in.sin_zero));
    //bzero(&(server_in.sin_zero), sizeof(server_in.sin_zero));

    /* linux的bug，重新建立连接会报错 */
    if (setsockopt(serverSockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt)) < 0)
    {
        close(serverSockfd);
        SOCK_ERR("Error: Could not set reuse address option");
        return -1;
    }

    ret = bind(serverSockfd, (struct sockaddr *)&server_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("bind err");
        close(serverSockfd);
        return -1;
    }

    ret = listen(serverSockfd, MAX_LISTEN_QUEUE);
    if (-1 == ret)
    {
        SOCK_ERR("listen err");
        close(serverSockfd);
        return -1;
    }

    recvBuf = (char *)malloc(RECV_BUFFER_SIZE * sizeof(char));
    memset(recvBuf, 0, RECV_BUFFER_SIZE * sizeof(char));

    //while (1)
    {
        //for (i = 0; i < MAX_LISTEN_QUEUE; i++)
        {
            sin_size = sizeof(struct sockaddr);
            newSockfd[i] = accept(serverSockfd, (struct sockaddr *)&client_in[i], &sin_size);
            if (-1 == newSockfd[i])
            {
                SOCK_ERR("accept error");
            }
            else
            {
                //int flags = fcntl(newSockfd[i], F_GETFL, 0); 
                //fcntl(newSockfd[i], F_SETFL, flags | O_NONBLOCK);
                while (1)
                {
                    tv.tv_sec = SELECT_TIMEOUT_ITV;
                    tv.tv_usec = 0;
                    FD_ZERO(&fdSetRead);
                    FD_SET(newSockfd[i], &fdSetRead); //加入read监听队列
                    ret = select(newSockfd[i] + 1, &fdSetRead, NULL, NULL, &tv);
                    printf("tv.sec = %d\n", tv.tv_sec); //每次select完之后，tv被赋值为尚未等待的时长，例如设置5s，但select等了2s就返回了，那tv中保存3s。
                    if (-1 == ret)
                    {
                        SOCK_ERR("select error");
                        if (errno == EINTR) //注意，即使信号设置了SA_RESTART，select也不会restart
                        {
                            continue;
                        }
                        close(newSockfd[i]);
                        break;
                    }
                    else if (0 != ret)
                    {
                        /* 这时fdSetRead会被设置为只包含那些有数据的sockfd集合 */
                        /* 判断是不是想要的sockfd有数据了，
                        因为只要有连接上有数据select就会返回 */
                        if (!FD_ISSET(newSockfd[i], &fdSetRead))
                        {
                            continue;
                        }

                        recvLen = recv(newSockfd[i], recvBuf, RECV_BUFFER_SIZE * sizeof(char), 0);
                        if (recvLen == 0)
                        {
                            SOCK_LOG("peer closed.\n");
                            close(newSockfd[i]); //需要同时将newSockfd[i]从监听队列移除
                            continue;
                        }
                        else if (-1 == recvLen)
                        {
                            perror("recv error");
                        }
                        else
                        {
                            SOCK_LOG("%d recv: %s, len = %d\n", newSockfd[i], recvBuf, recvLen);
                        }

                        if (!strncmp("end", recvBuf, 3))
                        {
                            break;
                        }
                    }
                    else
                    {
                        SOCK_LOG("no data\n");

                        /* 如果是非阻塞（这里MSG_DONTWAIT或fcntl设置F_SETFL为O_NONBLOCK），没有数据也强收的话，会直接返回EAGAIN，即Resource temporarily unavailable */
                        recv(newSockfd[i], recvBuf, RECV_BUFFER_SIZE * sizeof(char), 0);
                    }
                    //sleep(1);
                }
                close(newSockfd[i]);
            }
        }

        //sleep(2);
    }

    free(recvBuf);
    close(serverSockfd);
    SOCK_LOG("end\n");
    return 0;
}

client端的代码：

#if 0
socket可使用的协议族的域最常用的是AF_UNIX(AF_LOCAL)和AF_INET，这些协议族在linux/socket.h中定义。

AF_UNIX的套接字地址定义成sockaddr_un结构，在sys/un.h中：
struct sockaddr_un
{
    __SOCKADDR_COMMON (sun_);
    char sun_path[108];     // Path name.
};
其中__SOCKADDR_COMMON的定义为：
#define __SOCKADDR_COMMON(sa_prefix) \
  sa_family_t sa_prefix##family
所以实际上是：
struct sockaddr_un
{
    sa_family_t sun_family;
    char sun_path[108];
};

AF_INET的套接字地址定义为sockaddr_in结构，这里的in代表internet。在linux/in.h中：
#define __SOCK_SIZE__   16      /* sizeof(struct sockaddr)  */
struct sockaddr_in {
  sa_family_t       sin_family; /* Address family       */
  __be16            sin_port;   /* Port number          */
  struct in_addr    sin_addr;   /* Internet address     */
  /* Pad to size of 'struct sockaddr', 即在后面添0直到整个结构体大小和sizeof(sockaddr)相同. */
  unsigned char     __pad[__SOCK_SIZE__ - sizeof(short int) -
            sizeof(unsigned short int) - sizeof(struct in_addr)];
};

/* Internet address. */
struct in_addr {
    __be32  s_addr;
};

其他数据结构：
typedef uint32_t in_addr_t;

typedef unsigned short int sa_family_t;

struct sockaddr {
    sa_family_t sa_family;  /* address family, AF_xxx   */
    char        sa_data[14];    /* 14 bytes of protocol address */
};

有一点很重要，就是一个指向struct sockaddr_in的指针可以声明指向一个sturct sockaddr的结构。

#endif

#include <stdio.h>
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <string.h>
#include <stdlib.h>

#include "sockComm.h"

#define MAX_LISTEN_QUEUE 5
#define SEND_BUFFER_SIZE 20

/* 一个基于TCP的socket client */
int main()
{
    int clientSockfd = -1;
    int ret = -1;
    struct sockaddr_in dest_in;
    char * destIp = "192.168.3.100";
    char * sendBuf[] = 
        {
            "hello server 000!", 
            "hello server 111!", 
            "hello server 222!", 
            "end", 
            NULL,
        };
    int i;

    clientSockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == clientSockfd)
    {
        SOCK_ERR("create client socket error");
        goto end;
    }

    dest_in.sin_family = AF_INET;
    dest_in.sin_port = htons(6603);
    dest_in.sin_addr.s_addr = inet_addr(destIp);
    memset(&dest_in.sin_zero, 0, sizeof(dest_in.sin_zero));
    //bzero(&(cin.sin_zero), sizeof(cin.sin_zero));

    ret = connect(clientSockfd, (struct sockaddr *)&dest_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("connect err");
        goto end;
    }

    i = 0;
    while (sendBuf[i] != NULL)
    {
        sleep(8);
        ret = send(clientSockfd, sendBuf[i], SEND_BUFFER_SIZE * sizeof(char), 0);
        if (-1 == ret)
        {
            SOCK_ERR("send err");
            goto end;
        }
        SOCK_LOG("send: %s\n", sendBuf[i]);
        i++;
    }

end:
    if (-1 != clientSockfd)
    {
        close(clientSockfd);
    }
#if 0
    if (sendBuf)
    {
        free(sendBuf);
    }
#endif
    SOCK_LOG("end\n");
    return 0;
}

sockComm.h

#ifndef __SOCK_COMM_H__
#define __SOCK_COMM_H__

#ifdef SOCK_DEBUG
#define SOCK_LOG    printf
#define SOCK_ERR    perror
#else
#define SOCK_LOG    
#define SOCK_ERR    
#endif

#endif

Makefile：

CC = gcc
LD = ld

CFLAGS += -DSOCK_DEBUG
CLI_OBJS = client_sel.o
SER_OBJS = server_sel.o

sockclient: sockclient.o
    @$(CC) $< -o $@

sockclient.o: $(CLI_OBJS)
    @$(LD) -r -o $@ $(CLI_OBJS)

%.o: %.c
    @$(CC) -c $(CFLAGS) -o $@ $<

sockserver: sockserver.o
    @$(CC) $< -o $@

sockserver.o: $(SER_OBJS)
    @$(LD) -r -o $@ $(SER_OBJS)

%.o: %.c
    @$(CC) -c $(CFLAGS) -o $@ $<

all: clean sockclient sockserver

clean:
    @rm -f *.o sockclient sockserver

使用epoll的server（client完全相同）：

#include <stdio.h>
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <sys/poll.h> //poll, pollfd
#include <netdb.h> //hostent
#include <string.h> // bzero, memset
#include <stdlib.h>
#include <sys/epoll.h> // epoll
#include <asm/fcntl.h> // for fcntl and its params

#include "sockComm.h"

#define MAX_LISTEN_QUEUE 20
#define RECV_BUFFER_SIZE 8
#define EPOLL_TIMEOUT_ITV_SEC 3
#define EPOLL_MAX_SIZE 128

int setnonblocking(int sockfd)     
{     
    if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)        
        return -1;  
    return 0;     
}    

/* 一个基于TCP的socket server */
int main()
{
    int serverSockfd;
    int ret = -1;
    struct sockaddr_in server_in;
    struct sockaddr_in client_in[MAX_LISTEN_QUEUE];
    int newSockfd[MAX_LISTEN_QUEUE];
    char * localIp = "192.168.3.100";
    char * recvBuf = NULL;
    int recvLen;
    int sin_size = 0;
    int i = 0;

    int opt = 1;
    int epfd = -1;
    struct epoll_event event, events[MAX_LISTEN_QUEUE];
    int nfds = 0;
    int n;

    serverSockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == serverSockfd)
    {
        SOCK_ERR("create client socket error");
        return -1;
    }
#if 0 //test: get localhost ip addr
    char * hostname;
    int hostnameLen;
    struct hostent * ht;

    hostname = (char *)malloc(20 * sizeof(char));
    memset(hostname, 0, 20 * sizeof(char));
    gethostname(hostname, 20);
    printf("hostname is %s\n", hostname);
    ht = gethostbyname(hostname);
    localIp = inet_ntoa (*((struct in_addr *)(ht->h_addr_list[0])));
    SOCK_LOG("server ip is %s\n", localIp);
    free(hostname);
#endif
    server_in.sin_family = AF_INET;
    server_in.sin_port = htons(6603);
    server_in.sin_addr.s_addr = inet_addr(localIp);
    //memset(&server_in.sin_zero, 0, sizeof(server_in.sin_zero));
    bzero(&(server_in.sin_zero), sizeof(server_in.sin_zero));

    /* linux的bug，重新建立连接会报错 */
    if (setsockopt(serverSockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt)) < 0)
    {
        close(serverSockfd);
        SOCK_ERR("Error: Could not set reuse address option");
        return -1;
    }

    ret = bind(serverSockfd, (struct sockaddr *)&server_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("bind err");
        close(serverSockfd);
        return -1;
    }



    ret = listen(serverSockfd, MAX_LISTEN_QUEUE);
    if (-1 == ret)
    {
        SOCK_ERR("listen err");
        close(serverSockfd);
        return -1;
    }

    recvBuf = (char *)malloc(RECV_BUFFER_SIZE * sizeof(char));
    if (!recvBuf)
    {
        SOCK_ERR("malloc recvBuf err");
        close(serverSockfd);
        return -1;
    }
    memset(recvBuf, 0, RECV_BUFFER_SIZE * sizeof(char));

    //while (1)
    {
        //for (i = 0; i < MAX_LISTEN_QUEUE; i++)
        {
            sin_size = sizeof(struct sockaddr);
            newSockfd[i] = accept(serverSockfd, (struct sockaddr *)&client_in[i], &sin_size);
            if (-1 == newSockfd[i])
            {
                SOCK_ERR("accept error");
            }
            else
            {
                epfd = epoll_create(EPOLL_MAX_SIZE); /* epoll要用到一个fd。 */
                if (-1 == epfd)
                {
                    SOCK_ERR("epoll error");
                    goto end;
                }

                /* 添加fd进去。并注册要监听的事件。 */
                event.events = EPOLLIN;
                event.events &= ~EPOLLET; //默认是电平触发，所以这句话没必要。
                    event.data.fd = newSockfd[i];
                ret = epoll_ctl(epfd, EPOLL_CTL_ADD, newSockfd[i], &event);
                if (-1 == ret)
                {
                    SOCK_ERR("epoll_ctl error");
                }

                /* 开始接收数据。 */
                while (1)
                {
                    /* 监听到的fd集合以及发生的事件会记录在events中。 */
                    nfds = epoll_wait(epfd, events, MAX_LISTEN_QUEUE, EPOLL_TIMEOUT_ITV_SEC * 1000);
                    if (-1 == nfds)
                    {
                        SOCK_ERR("epoll wait error");
                        close(newSockfd[i]);
                        break;
                    }
                    else if (nfds != 0) //有监听到，nfds是fd的数量
                    {
                        for (n = 0; n < nfds; n++)
                        {
                            if (events[n].data.fd == newSockfd[i] && (events[n].events & EPOLLIN))
                            {
                                //setnonblocking(events[n].data.fd);

                                /* 如果是边沿触发的话，这里要用while保证每次都收完再回去epoll_wait。
                                不然小buffer的话可能收不完整。 */
                                /* while ( */recvLen = recv(events[n].data.fd, recvBuf, RECV_BUFFER_SIZE * sizeof(char), 0);
                                {
                                    if (-1 == recvLen)
                                    {
                                        SOCK_ERR("recv error");
                                        break;
                                    }
                                    else
                                    {
                                        SOCK_LOG("%d recv: %s, len = %d\n", events[n].data.fd, recvBuf, recvLen);
                                    }

                                    if (!strncmp("end", recvBuf, 3))
                                    {
                                        epoll_ctl(epfd, EPOLL_CTL_DEL, events[n].data.fd, NULL);
                                        //break;
                                        goto end;
                                    }   
                                }
                            }
                        }
                    }
                    else
                    {
                        SOCK_LOG("no data\n");
                    }
                    sleep(1);
                }
                close(newSockfd[i]);
            }
        }

        //sleep(2);
    }
end:
    free(recvBuf);
    close(serverSockfd);
    if (epfd != -1)
        close(epfd);
    SOCK_LOG("end\n");
    return 0;
}

一个简单UDP server：

#include <stdio.h>
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <string.h>
#include <stdlib.h>

#include "sockComm.h"

#define MAX_LISTEN_QUEUE 5
#define RECV_BUFFER_SIZE 4

/* 一个基于UDP的socket server */
int main()
{
    int serverSockfd;
    int ret = -1;
    struct sockaddr_in server_in;
    struct sockaddr_in client_in[MAX_LISTEN_QUEUE];
    int newSockfd[MAX_LISTEN_QUEUE];
    char * localIp = "192.168.3.100";
    char * remoteIp = "192.168.3.100";
    char * recvBuf = NULL;
    int recvLen;
    int sin_size = 0;
    int i = 0;

    int opt = 1;

    serverSockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == serverSockfd)
    {
        SOCK_ERR("create client socket error.\n");
        return -1;
    }

    server_in.sin_family = AF_INET;
    server_in.sin_port = htons(6601);
    server_in.sin_addr.s_addr = inet_addr(localIp);
    memset(&server_in.sin_zero, 0, sizeof(server_in.sin_zero));
    //bzero(&(server_in.sin_zero), sizeof(server_in.sin_zero));

    /* linux的bug，重新建立连接会报错 */
    if (setsockopt(serverSockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt)) < 0)
    {
        SOCK_ERR("Error: Could not set reuse address option");
        goto end;
    }

    ret = bind(serverSockfd, (struct sockaddr *)&server_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("bind err");
        goto end;
    }
#if 0
    ret = listen(serverSockfd, MAX_LISTEN_QUEUE);
    if (-1 == ret)
    {
        SOCK_ERR("listen err");
        goto end;
    }
#endif
    recvBuf = (char *)malloc(RECV_BUFFER_SIZE * sizeof(char));
    memset(recvBuf, 0, RECV_BUFFER_SIZE * sizeof(char));

    //while (1)
    {
        //for (i = 0; i < MAX_LISTEN_QUEUE; i++)
        {
            #if 0
            sin_size = sizeof(struct sockaddr);
            newSockfd[i] = accept(serverSockfd, (struct sockaddr *)&client_in[i], &sin_size);
            if (-1 == newSockfd[i])
            {
                perror("accept error.\n");
            }
            else
            #endif

            client_in[i].sin_family = AF_INET;
            client_in[i].sin_port = htons(6601);
            client_in[i].sin_addr.s_addr = inet_addr(remoteIp);
            memset(&client_in[i].sin_zero, 0, sizeof(client_in[i].sin_zero));

            {
                sin_size = sizeof(struct sockaddr);
                recvLen = recvfrom(serverSockfd, recvBuf, RECV_BUFFER_SIZE * sizeof(char), 0,
                    (struct sockaddr *)&client_in[i], &sin_size);
                if (-1 == recvLen)
                {
                    SOCK_ERR("recv error");
                    goto end;
                }
                else
                {
                    SOCK_LOG("recv: %s, len = %d\n", recvBuf, recvLen);
                }
            }
        }

        //sleep(2);
    }
end:
    if (-1 != serverSockfd)
    {
        close(serverSockfd);
    }
    if (recvBuf)
    {
        free(recvBuf);
    }

    SOCK_LOG("end\n");
    return 0;
}

UDP client：

#if 0
socket可使用的协议族的域最常用的是AF_UNIX(AF_LOCAL)和AF_INET，这些协议族在linux/socket.h中定义。

AF_UNIX的套接字地址定义成sockaddr_un结构，在sys/un.h中：
struct sockaddr_un
{
    __SOCKADDR_COMMON (sun_);
    char sun_path[108];     // Path name.
};
其中__SOCKADDR_COMMON的定义为：
#define __SOCKADDR_COMMON(sa_prefix) \
  sa_family_t sa_prefix##family
所以实际上是：
struct sockaddr_un
{
    sa_family_t sun_family;
    char sun_path[108];
};

AF_INET的套接字地址定义为sockaddr_in结构，这里的in代表internet。在linux/in.h中：
#define __SOCK_SIZE__   16      /* sizeof(struct sockaddr)  */
struct sockaddr_in {
  sa_family_t       sin_family; /* Address family       */
  __be16            sin_port;   /* Port number          */
  struct in_addr    sin_addr;   /* Internet address     */
  /* Pad to size of 'struct sockaddr', 即在后面添0直到整个结构体大小和sizeof(sockaddr)相同. */
  unsigned char     __pad[__SOCK_SIZE__ - sizeof(short int) -
            sizeof(unsigned short int) - sizeof(struct in_addr)];
};

/* Internet address. */
struct in_addr {
    __be32  s_addr;
};

其他数据结构：
typedef uint32_t in_addr_t;

typedef unsigned short int sa_family_t;

struct sockaddr {
    sa_family_t sa_family;  /* address family, AF_xxx   */
    char        sa_data[14];    /* 14 bytes of protocol address */
};

有一点很重要，就是一个指向struct sockaddr_in的指针可以声明指向一个sturct sockaddr的结构。

#endif

#include <stdio.h>
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <string.h>
#include <stdlib.h>

#include "sockComm.h"

#define MAX_LISTEN_QUEUE 5
#define SEND_BUFFER_SIZE 20

/* 一个基于UDP的socket client */
int main()
{
    int clientSockfd = -1;
    int ret = -1;
    struct sockaddr_in dest_in;
    char * destIp = "192.168.3.100";
    char * sendBuf = "hello server!";

    clientSockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (-1 == clientSockfd)
    {
        SOCK_ERR("create client socket error");
        goto end;
    }

    dest_in.sin_family = AF_INET;
    dest_in.sin_port = htons(6601);
    dest_in.sin_addr.s_addr = inet_addr(destIp);
    memset(&dest_in.sin_zero, 0, sizeof(dest_in.sin_zero));
    //bzero(&(cin.sin_zero), sizeof(cin.sin_zero));
#if 0
    ret = connect(clientSockfd, (struct sockaddr *)&dest_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("connect err.\n");
        goto end;
    }
#endif
    ret = sendto(clientSockfd, sendBuf, SEND_BUFFER_SIZE * sizeof(char), 0,
            (struct sockaddr *)&dest_in, sizeof(struct sockaddr));
    if (-1 == ret)
    {
        SOCK_ERR("send err");
        goto end;
    }
    SOCK_LOG("send: %s\n", sendBuf);

end:
    if (-1 != clientSockfd)
    {
        close(clientSockfd);
    }
#if 0
    if (sendBuf)
    {
        free(sendBuf);
    }
#endif
    SOCK_LOG("end\n");
    return 0;
}
去级得骨灰
关注
专栏目录
30、JAVA进阶——Socket编程
不迁怒，不贰过。小知识，大智慧。
10-13 2万+
一、Socket知识 1. Socket概述 2. Socket通信原理 3. java.net包 二、基于TCP协议的Socket编程 1.Socket类和ServerSocket类 2.使用Socket编程实现登录功能 三、基于UDP协议的Socket编程 1.DatagramPacket类和DatagramSocket类 2.使用Socket编程实现客户咨询
简单的 Socket实例
Phoenix_smf的博客
04-28 465
Socket简介： 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。...
socket编程
JustinACE的专栏
02-19 440
从一个简单的使用TCP例子开始socket编程，其基本步骤如下： server                                                  client   +++++++                                          ++++++++ 创建socket                        
C++ 网络编程：完成端口IOCP
最新发布
weixin_36967492的博客
08-11 30
IOCP（I/O Completion Ports）是Windows操作系统提供的一种高效的异步I/O模型，主要用于处理大量并发I/O请求的应用程序。IOCP通过以下几个关键概念来实现高效的异步I/O：Completion Port：这是一个内核对象，多个I/O操作可以与其关联。每个完成端口可以关联多个线程，用于处理I/O...
socket案例
一个人的专栏
02-07 419
http://www.cnblogs.com/linzheng/archive/2011/01/23/1942328.html
socket例子
weixin_34161029的博客
06-29 527
Complete Client Code #include <stdio.h> #include "winsock2.h" void main() { // Initialize Winsock. WSADATA wsaData; int iResult = WSAStartup( MAKEWORD(2,2), &wsaData ...
Socket 案例
xiaohua616的博客
07-05 722
Socket 案例，源码教程
python代码，用epoll处理socket并发（csdn）————程序.pdf
12-03
在Python编程中，处理并发的网络连接通常会涉及到I/O多路复用技术，这里主要讲解的是使用`select.epoll()`来实现socket并发处理的方法。`epoll`是Linux内核提供的一种高效I/O事件通知机制，适用于大量并发连接的情况...
安卓Android源码——例子源码Socket实现粗略的聊天室功能.zip
10-11
在这个例子中，我们可能会看到一个Socket作为客户端与服务器端的通信桥梁，通过发送和接收消息来实现聊天功能。 源码中的关键部分可能包括以下几个组件： 1. **服务器端（Server）**：服务器端通常负责监听特定...
完成端口通讯服务器（IOCP Socket Server）设计——（5）
09-21
### 完成端口通讯服务器（IOCP Socket Server）设计——（5）妙用PerHandleData和PerIoData #### PerIoData PerIoData在完成端口通讯服务器设计中扮演着重要的角色，主要用来存储单次IO操作的相关信息。在本节中，...
Socket编程例子
03-13
Socket编程例子
一个最简洁的Socket例子
01-13
一个最简洁的Socket例子！适合初学者，高手就不要看了！：）服务端接收和发送消息，客户端也可以接收和发送消息！利用WinSocket实现......D6默认有安装，D7默认没有安装，需自己安装：component->install packages->安装 C:Program FilesBorlandDelphi7Bindclsockets70.bpl
socket示例代码
08-12
socket示例代码，包含客户端和服务端代码，实现客户端与服务端之间的socket通信
Socket 实例代码
09-14
Socket 实例代码，包括我一直使用的网络调试助手，欢迎下载使用！
websocket使用案例
08-28
websocket使用入门案例，详情请见博客http://blog.csdn.net/u012702547/article/details/77655826
socket实例
fanx021的博客
06-02 339
server：#undef UNICODE #define WIN32_LEAN_AND_MEAN #include &lt;windows.h&gt; #include &lt;winsock2.h&gt; #include &lt;ws2tcpip.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; /**Need to li...
socket案例一
huangdroid的专栏---不要让任何事情成为你不去学习的理由！
09-11 458
编写一个网络应用程序，有客户端与服务器端；当客户端向服务器端发送请求时，客户端输出服务器端返回的字符串。                              回顾下socket的开发步骤： 1) 建立Socket连接 2) 获得输入/输出流 3）读/写数据 4) 关闭输入/输出流 5) 关闭Socket
Socket简单实例（简单实现调用accpet()方法开始监听）
桃欢李笑
05-21 1793
Socket编程 　　Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。 　　Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输
java socket 释放端口_java——网络编程
05-26
在 Java 中，Socket 编程是通过 java.net.Socket 和 java.net.ServerSocket 实现的。如果你想释放一个端口，需要先关闭相关的 Socket 或 ServerSocket。 下面是一个使用 ServerSocket 的例子： ```java import ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值