socketϵͳԴ?系统?

       源代码奉上，流程图。源码。系统。源码上海拼团商城网站源码这个太简单了，系统你自己看看。源码。系统。源码。系统。源码。系统。源码

       //TCP

       //服务器端程序

       #include< stdio.h >

       #include< stdlib.h >

       #include< windows.h >

       #include< winsock.h >

       #include< string.h >

       #pragma comment( lib,系统traits源码 "ws2_.lib" )

       #define PORT

       #define BACKLOG

       #define TRUE 1

       void main( void )

       {

       int iServerSock;

       int iClientSock;

       char *buf = "hello, world!\n";

       struct sockaddr_in ServerAddr;

       struct sockaddr_in ClientAddr;

       int sin_size;

       WSADATA WSAData;

       if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化

       {

       printf( "initializationing error!\n" );

       WSACleanup( );

       exit( 0 );

       }

       if( ( iServerSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )

       {

       printf( "创建套接字失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       ServerAddr.sin_family = AF_INET;

       ServerAddr.sin_port = htons( PORT );//监视的端口号

       ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP

       memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );

       if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )

       {

       printf( "bind调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       if( listen( iServerSock, BACKLOG ) == -1 )

       {

       printf( "listen调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       while( TRUE )

       {

       sin_size = sizeof( struct sockaddr_in );

       iClientSock = accept( iServerSock, ( struct sockaddr * )&ClientAddr, &sin_size );

       if( iClientSock == -1 )

       {

       printf( "accept调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       printf( "服务器连接到%s\n", inet_ntoa( ClientAddr.sin_addr ) );

       if( send( iClientSock, buf, strlen( buf ), 0 ) == -1 )

       {

       printf( "send调用失败!" );

       closesocket( iClientSock );

       WSACleanup( );

       exit( 0 );

       }

       }

       }

       /////客户端程序

       #include< stdio.h >

       #include< stdlib.h >

       #include< windows.h >

       #include< winsock.h >

       #include< string.h >

       #pragma comment( lib, "ws2_.lib" )

       #define PORT

       #define BACKLOG

       #define TRUE 1

       #define MAXDATASIZE

       void main( void )

       {

       int iClientSock;

       char buf[ MAXDATASIZE ];

       struct sockaddr_in ServerAddr;

       int numbytes;

       // struct hostent *he;

       WSADATA WSAData;

       // int sin_size;

       /* if( ( he = gethostbyname( "liuys" ) ) == NULL )

       {

       printf( "gethostbyname调用失败!" );

       WSACleanup( );

       exit( 0 );

       }

       */

       if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化

       {

       printf( "initializationing error!\n" );

       WSACleanup( );

       exit( 0 );

       }

       if( ( iClientSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )

       {

       printf( "创建套接字失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       ServerAddr.sin_family = AF_INET;

       ServerAddr.sin_port = htons( PORT );

       // ServerAddr.sin_addr = *( ( struct in_addr * )he->h_addr );

       ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP

       memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );

       if( connect( iClientSock, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) ) == -1 )

       {

       printf( "connect失败!" );

       WSACleanup( );

       exit( 0 );

       }

       numbytes = recv( iClientSock, buf, MAXDATASIZE, 0 );

       if( numbytes == -1 )

       {

       printf( "recv失败!" );

       WSACleanup( );

       exit( 0 );

       }

       buf[ numbytes ] = '\0';

       printf( "Received: %s", buf );

       closesocket( iClientSock );

       WSACleanup( );

       }

       /////UDP

       //服务器

       #include< stdio.h >

       #include< string.h >

       #include< winsock.h >

       #include< windows.h >

       #pragma comment( lib, "ws2_.lib" )

       #define PORT

       #define BACKLOG

       #define TRUE 1

       #define MAXDATASIZE

       void main( void )

       {

       int iServerSock;

       // int iClientSock;

       int addr_len;

       int numbytes;

       char buf[ MAXDATASIZE ];

       struct sockaddr_in ServerAddr;

       struct sockaddr_in ClientAddr;

       WSADATA WSAData;

       if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )

       {

       printf( "initializationing error!\n" );

       WSACleanup( );

       exit( 0 );

       }

       iServerSock = socket( AF_INET, SOCK_DGRAM, 0 );

       if( iServerSock == INVALID_SOCKET )

       {

       printf( "创建套接字失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       ServerAddr.sin_family = AF_INET;

       ServerAddr.sin_port = htons( PORT );//监视的端口号

       ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP

       memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );

       if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )

       {

       printf( "bind调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       addr_len = sizeof( struct sockaddr );

       numbytes = recvfrom( iServerSock, buf, MAXDATASIZE, 0, ( struct sockaddr * ) & ClientAddr, &addr_len );

       if( numbytes == -1 )

       {

       printf( "recvfrom调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       printf( "got packet from %s\n", inet_ntoa( ClientAddr.sin_addr ) );

       printf( "packet is %d bytes long\n", numbytes );

       buf[ numbytes ] = '\0';

       printf( "packet contains \"%s\"\n", buf );

       closesocket( iServerSock );

       WSACleanup( );

       }

       //客户端

       #include< stdio.h >

       #include< stdlib.h >

       #include< windows.h >

       #include< winsock.h >

       #include< string.h >

       #pragma comment( lib, "ws2_.lib" )

       #define PORT

       #define MAXDATASIZE

       void main( void )

       {

       int iClientSock;

       struct sockaddr_in ServerAddr;

       int numbytes;

       char buf[ MAXDATASIZE ] = { 0 };

       WSADATA WSAData;

       if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )

       {

       printf( "initializationing error!\n" );

       WSACleanup( );

       exit( 0 );

       }

       if( ( iClientSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )

       {

       printf( "创建套接字失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       ServerAddr.sin_family = AF_INET;

       ServerAddr.sin_port = htons( PORT );

       ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP

       memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );

       numbytes = sendto( iClientSock, buf, strlen( buf ), 0, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) );

       if( numbytes == -1 )

       {

       printf( "sendto调用失败!\n" );

       WSACleanup( );

       exit( 0 );

       }

       printf( "sent %d bytes to %s\n", numbytes, inet_ntoa( ServerAddr.sin_addr ) );

       closesocket( iClientSock );

       WSACleanup( );

       }

从Linux源码看Socket(TCP)的listen及连接队列

       了解Linux内核中Socket (TCP)的"listen"及连接队列机制是深入理解网络编程的关键。本文将基于Linux 3.内核版本，从源码角度解析Server端Socket在进行"listen"时的具体实现。

       建立Server端Socket需要经历socket、bind、listen、accept四个步骤。本文聚焦于"listen"步骤，深入探讨其内部机理。

       通过socket系统调用，我们可以创建一个基于TCP的Socket。这里直接展示了与TCP Socket相关联的操作函数。

       接着，我们深入到"listen"系统调用。注意，sofia源码glibc的INLINE_SYSCALL对返回值进行了封装，仅保留0和-1两种结果，并将错误码的绝对值记录在errno中。其中，backlog参数至关重要，设置不当会引入隐蔽的陷阱。对于Java开发者而言，框架默认backlog值较小（默认），这可能导致微妙的行为差异。

       进入内核源码栈，我们发现内核对backlog值进行了调整，限制其不超过内核参数设置的somaxconn值。

       核心调用程序为inet_listen。其中，nirvana源码除了fastopen外的逻辑（fastopen将在单独章节深入讨论）最终调用inet_csk_listen_start，将sock链入全局的listen hash表，实现对SYN包的高效处理。

       值得注意的是，SO_REUSEPORT特性允许不同Socket监听同一端口，实现内核级的负载均衡。Nginx 1.9.1版本启用此功能后，性能提升3倍。

       半连接队列与全连接队列是连接处理中的关键组件。通常提及的sync_queue与accept_queue并非全貌，sync_queue实际上是syn_table，而全连接队列为icsk_accept_queue。在三次握手过程中，这两个队列分别承担着不同角色。rostopic源码

       在连接处理中，除了qlen与sk_ack_backlog计数器外，qlen_young计数器用于特定场景下的统计。SYN_ACK的重传定时器在内核中以ms为间隔运行，确保连接建立过程的稳定。

       半连接队列的存在是为抵御半连接攻击，避免消耗大量内存资源。通过syn_cookie机制，内核能有效防御此类攻击。

       全连接队列的最大长度受到限制，超过somaxconn值的连接会被内核丢弃。若未启用tcp_abort_on_overflow特性，客户端可能在调用时才会察觉到连接被丢弃。启用此特性或增大backlog值是应对这一问题的策略。

       backlog参数对半连接队列容量产生影响，导致内核发送cookie校验时出现常见的内存溢出警告。

       总结而言，TCP协议在数十年的演进中变得复杂，深入阅读源码成为分析问题的重要途径。本文深入解析了Linux内核中Socket (TCP)的"listen"及连接队列机制，旨在帮助开发者更深入地理解网络编程。

从 Linux源码 看 Socket(TCP)的accept

       从 Linux 源码角度探究 Server 端 Socket 的 Accept 过程（基于 Linux 3. 内核），以下是一系列关键步骤的解析。

       创建 Server 端 Socket 需依次执行 socket、bind、listen 和 accept 四个步骤。其中，socket 系统调用创建了一个 SOCK_STREAM 类型的 TCP Socket，其操作函数为 TCP Socket 所对应的 ops。在进行 Accept 时，关键在于理解 Accept 的功能，即创建一个新的 Socket 与对端的 connect Socket 进行连接。

       在具体实现中，核心函数 sock->ops->accept 被调用。关注 TCP 实现即 inet_stream_ops->accept，其进一步调用 inet_accept。核心逻辑在于 inet_csk_wait_for_connect，用于管理 Accept 的超时逻辑，避免在超时时惊群现象的发生。

       EPOLL 的实现中，"惊群"现象是由水平触发模式下 epoll_wait 重新塞回 ready_list 并唤醒多个等待进程导致的。虽然 epoll_wait 自身在有中断事件触发时不惊群，但水平触发机制仍会造成类似惊群的效应。解决此问题，通常采用单线程专门处理 accept，如 Reactor 模式。

       针对"惊群"问题，Linux 提供了 so_reuseport 参数，允许多个 fd 监听同一端口号，内核中进行负载均衡（Sharding），将 accept 任务分散到不同 Socket 上。这样，可以有效利用多核能力，提升 Socket 分发能力，且线程模型可改为多线程 accept。

       在 accept 过程中，accept_queue 是关键成员，用于填充添加待处理的连接。用户线程通过 accept 系统调用从队列中获取对应的 fd。值得注意的是，当用户线程未能及时处理时，内核可能会丢弃三次握手成功的连接，导致某些意外现象。

       综上所述，理解 Linux Socket 的 Accept 过程需要深入源码，关注核心函数与机制，以便优化 Server 端性能，并有效解决"惊群"等问题，提升系统处理能力。

linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。。谢谢

       server:

       #include <stdio.h>

       #include <errno.h>

       #include <unistd.h>

       #include <signal.h>

       #include <stdlib.h>

       #include <sys/types.h>

       #include <sys/socket.h>

       #include <arpa/inet.h>

       #include <netinet/in.h>

       #include <syslog.h>

       #include <sys/time.h>

       #include <string.h>

       #include <fcntl.h>

       #include <sys/wait.h>

       #define MAXDATASIZE

       #define SERVPORT

       #define BACKLOG

       int SendFileToServ(const char *path, const char *FileName, const char *ip)

       {

       #define PORT

        int sockfd;

        int recvbytes;

        char buf[MAXDATASIZE];

        char send_str[MAXDATASIZE];

        char filepath[] = { 0};

        struct sockaddr_in serv_addr;

        FILE *fp;

        sprintf(filepath, "%s%s", path, FileName);

        if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

        {

        perror("socket");

        return 1;

        }

        bzero(&serv_addr,sizeof(struct sockaddr_in));

        serv_addr.sin_family=AF_INET;

        serv_addr.sin_port=htons(PORT);

        inet_aton(ip, &serv_addr.sin_addr);

        int IErrCount = 0;

       again:

        if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1)

        {

        if (5 == IErrCount)

        return 1;

        IErrCount++;

        perror("connect");

        sleep(2);

        goto again;

        }

        //if ((fp = fopen(FileName, "rb")) == NULL)

        if ((fp = fopen(filepath, "rb")) == NULL)

        {

        perror("fopen ");

        return 1;

        }

        recvbytes = write(sockfd, FileName, strlen(FileName));

        recvbytes = read(sockfd, buf, MAXDATASIZE);

        if (!memcmp(buf, "sendmsg", 7))

        {

        while(fgets(send_str, MAXDATASIZE, fp))

        {

        recvbytes = write(sockfd, send_str, strlen(send_str));

        recvbytes = read(sockfd, buf, MAXDATASIZE);

        if (recvbytes <= 0)

        {

        fclose(fp);

        close(sockfd);

        return 1;

        }

        if (memcmp(buf, "goon", 4))

        {

        fclose(fp);

        close(sockfd);

        return 1;

        }

        }

        recvbytes = write(sockfd, "end", 3);

        }

        else

        {

        fclose(fp);

        close(sockfd);

        return 1;

        }

        memset(buf, 0, MAXDATASIZE);

        if (read(sockfd, buf, MAXDATASIZE) <= 0)

        {

        close(sockfd);

        return 2;

        }

        char *Eptr = "nginx reload error";

        //printf("bf[%s]\n", buf);

        int ret;

        ret = strncmp(buf, Eptr, strlen(Eptr));

        //printf("%d\n", ret);

        if (!ret)

        {

        close(sockfd);

        return 2;

        }

        close(sockfd);

        return 0;

       }

       int mysyslog(const char * msg)

       {

        FILE *fp;

        if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)

        {

        return 0;

        }

        fprintf(fp, "[%s]\n", msg);

        fclose(fp);

        return 0;

       }

       static void quit_handler(int signal)

       {

        kill(0, SIGUSR2);

        syslog( LOG_NOTICE, "apuserv quit...");

        // do something exit thing ,such as close socket ,close mysql,free list

        // .....

        //i end

        exit(0);

       }

       static int re_conf = 0;

       static void reconf_handler(int signal)

       {

        re_conf=1;

        syslog(LOG_NOTICE,"apuserv reload configure file .");

        // 请在循环体中判断，如果re_conf == 1，请再次加载配置文件。

       }

       static int isrunning(void)

       {

        int fd;

        int ret;

        struct flock lock;

        lock.l_type = F_WRLCK;

        lock.l_whence = 0;

        lock.l_start = 0;

        lock.l_len = 0;

        const char *lckfile = "/tmp/apuserv.lock";

        fd = open(lckfile,O_WRONLY|O_CREAT);

        if (fd < 0) {

        syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);

        return 1;

        }

        if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {

        ret = fcntl(fd,F_GETLK,&lock);

        if (lock.l_type != F_UNLCK) {

        close(fd);

        return lock.l_pid;

        }

        else {

        fcntl(fd,F_SETLK,&lock);

        }

        }

        return 0;

       }

       int MyHandleBuff(const char *buf, char *str, char *FileName, char *pth)

       {

        sscanf(buf, "%s %s %s", pth, FileName, str);

        printf("path=%s\nfilename=%s\nip=%s\n", pth, FileName, str);

        return 0;

       }

       int main(int argc, char **argv)

       {

        int sockfd,client_fd;

        socklen_t sin_size;

        struct sockaddr_in my_addr,remote_addr;

        char buff[MAXDATASIZE];

        int recvbytes;

       #if 1

        int pid ;

        char ch ;

        int ret;

        int debug = 0;

        signal(SIGUSR1, SIG_IGN);

        signal(SIGUSR2, SIG_IGN);

        signal(SIGHUP, SIG_IGN);

        signal(SIGTERM, quit_handler);

        syslog(LOG_NOTICE,"apuserver start....");

        while ((ch = getopt(argc, argv, "dhV")) != -1) {

        switch (ch) {

        case 'd':

        debug = 1;

        break;

        case 'V':

        printf("Version:%s\n","1.0.0");

        return 0;

        case 'h':

        printf(" -d use daemon mode\n");

        printf(" -V show version\n");

        return 0;

        default:

        printf(" -d use daemon mode\n");

        printf(" -V show version\n");

        }

        }

        if (debug && daemon(0,0 ) ) {

        return -1;

        }

        if (isrunning()) {

        fprintf(stderr, "apuserv is already running\n");

        syslog(LOG_INFO,"apuserv is already running\n");

        exit(0);

        }

        while (1) {

        pid = fork();

        if (pid < 0)

        return -1;

        if (pid == 0)

        break;

        while ((ret = waitpid(pid, NULL, 0)) != pid) {

        syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);

        if (ret < 0)

        syslog(LOG_NOTICE, "waitpid errno:%d", errno);

        }

        kill(0, SIGUSR2);

        sleep(1);

        syslog(LOG_NOTICE,"restart apuserver");

        }

        signal(SIGHUP, reconf_handler);

        signal(SIGPIPE, SIG_IGN);

        signal(SIGUSR1,SIG_IGN);

        signal(SIGUSR2, SIG_DFL);

        signal(SIGTERM, SIG_DFL);

       #endif

        if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

        {

        perror("socket");

        exit(1);

        }

        bzero(&my_addr,sizeof(struct sockaddr_in));

        my_addr.sin_family=AF_INET;

        my_addr.sin_port=htons(SERVPORT);

        my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

        if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)

        {

        perror("bind");

        exit(1);

        }

        if(listen(sockfd,BACKLOG)==-1)

        {

        perror("listen");

        exit(1);

        }

        int nret;

        while(1)

        {

        sin_size = sizeof(struct sockaddr_in);

        if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)

        {

        perror("falied accept");

        continue;

        }

        memset(buff, 0, MAXDATASIZE);

        recvbytes = read(client_fd, buff, MAXDATASIZE);

        char str[] = { 0};

        char FileName[] = { 0};

        char path[] = { 0};

        MyHandleBuff(buff, str, FileName, path);

        if (recvbytes > 0)

        {

        nret = SendFileToServ(path, FileName, str);

        printf("nret[%d]\n", nret);

        if (1 == nret)

        write(client_fd, "send file error", );

        else if(2 == nret)

        write(client_fd, "reload nginx error", );

        else

        write(client_fd, "succ", 4);

        }

        close(client_fd);

        }

       }

       _________________________________________________

       client:

       #include <stdio.h>

       #include <errno.h>

       #include <unistd.h>

       #include <signal.h>

       #include <stdlib.h>

       #include <sys/types.h>

       #include <sys/socket.h>

       #include <arpa/inet.h>

       #include <netinet/in.h>

       #include <syslog.h>

       #include <sys/time.h>

       #include <string.h>

       #include <fcntl.h>

       #include <sys/wait.h>

       #define MAXDATASIZE

       #define SERVPORT

       #define BACKLOG

       int mysyslog(const char * msg)

       {

        FILE *fp;

        if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)

        {

        return 0;

        }

        fprintf(fp, "[%s]\n", msg);

        fclose(fp);

        return 0;

       }

       static void quit_handler(int signal)

       {

        kill(0, SIGUSR2);

        syslog( LOG_NOTICE, "apuserv quit...");

        // do something exit thing ,such as close socket ,close mysql,free list

        // .....

        //i end

        exit(0);

       }

       static int re_conf = 0;

       static void reconf_handler(int signal)

       {

        re_conf=1;

        syslog(LOG_NOTICE,"apuserv reload configure file .");

        // ·1nf == 1￡′μ?

        static int isrunning(void)

       {

        int fd;

        int ret;

        struct flock lock;

        lock.l_type = F_WRLCK;

        lock.l_whence = 0;

        lock.l_start = 0;

        lock.l_len = 0;

        const char *lckfile = "/tmp/dstserver.lock";

        fd = open(lckfile,O_WRONLY|O_CREAT);

        if (fd < 0) {

        syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);

        return 1;

        }

        if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {

        ret = fcntl(fd,F_GETLK,&lock);

        if (lock.l_type != F_UNLCK) {

        close(fd);

        return lock.l_pid;

        }

        else {

        fcntl(fd,F_SETLK,&lock);

        }

        }

        return 0;

       }

       int main(int argc, char **argv)

       {

        int sockfd,client_fd;

        socklen_t sin_size;

        struct sockaddr_in my_addr,remote_addr;

        char buff[MAXDATASIZE];

        int recvbytes;

       #if 1

        int pid ;

        char ch ;

        int ret;

        int debug = 0;

        signal(SIGUSR1, SIG_IGN);

        signal(SIGUSR2, SIG_IGN);

        signal(SIGHUP, SIG_IGN);

        signal(SIGTERM, quit_handler);

        syslog(LOG_NOTICE,"dstserver start....");

        while ((ch = getopt(argc, argv, "dhV")) != -1) {

        switch (ch) {

        case 'd':

        debug = 1;

        break;

        case 'V':

        printf("Version:%s\n","1.0.0");

        return 0;

        case 'h':

        printf(" -d use daemon mode\n");

        printf(" -V show version\n");

        return 0;

        default:

        printf(" -d use daemon mode\n");

        printf(" -V show version\n");

        }

        }

        if (debug && daemon(0,0 ) ) {

        return -1;

        }

        if (isrunning()) {

        fprintf(stderr, "dstserver is already running\n");

        syslog(LOG_INFO,"dstserver is already running\n");

        exit(0);

        }

        while (1) {

        pid = fork();

        if (pid < 0)

        return -1;

        if (pid == 0)

        break;

        while ((ret = waitpid(pid, NULL, 0)) != pid) {

        syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);

        if (ret < 0)

        syslog(LOG_NOTICE, "waitpid errno:%d", errno);

        }

        kill(0, SIGUSR2);

        sleep(1);

        syslog(LOG_NOTICE,"restart apuserver");

        }

        signal(SIGHUP, reconf_handler);

        signal(SIGPIPE, SIG_IGN);

        signal(SIGUSR1,SIG_IGN);

        signal(SIGUSR2, SIG_DFL);

        signal(SIGTERM, SIG_DFL);

       #endif

        if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)

        {

        perror("socket");

        exit(1);

        }

        bzero(&my_addr,sizeof(struct sockaddr_in));

        my_addr.sin_family=AF_INET;

        my_addr.sin_port=htons(SERVPORT);

        my_addr.sin_addr.s_addr = htonl(INADDR_ANY);

        if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)

        {

        perror("bind");

        exit(1);

        }

        if(listen(sockfd,BACKLOG)==-1)

        {

        perror("listen");

        exit(1);

        }

        char filepath[MAXDATASIZE]= { 0};

        FILE *fp;

        while(1)

        {

        sin_size = sizeof(struct sockaddr_in);

        if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)

        {

        perror("falied accept");

        continue;

        }

        memset(buff, 0, MAXDATASIZE);

        recvbytes = read(client_fd, buff, MAXDATASIZE);

        sprintf(filepath, "/etc/nginx/url_rule/%s", buff);

        if ((fp = fopen(filepath, "wb")) == NULL)

        {

        perror("fopen");

        close(client_fd);

        continue;

        }

        write(client_fd, "sendmsg", 7);

        while(read(client_fd, buff, MAXDATASIZE))

        {

        if (!memcmp(buff, "end", 3))

        {

        fclose(fp);

        break;

        }

        else

        {

        fprintf(fp, "%s", buff);

        write(client_fd, "goon", 4);

        }

        }

        //system("nginx -s reload");

        char *Sptr = "nginx reload succ";

        char *Eptr = "nginx reload error";

        int ret;

        ret = system("nginx -s reload");

        printf("ret[%d]\n", ret);

        if (ret != 0)

        {

        write(client_fd, Eptr, strlen(Eptr));

        }

        else

        {

        write(client_fd, Sptr, strlen(Sptr));

        }

        close(client_fd);

        }

       }

       以前写的：内容忘记了。不是很复杂你可以自己看！

如何编写简单的socket网络程序 如何编写基于TCP协议的网络程序

       ã€€ã€€ä¸‹é¢æ˜¯ä¸ªäººç”¨äº†ä¸€ä¸ªåˆ†é’Ÿå·¦å³çš„时间编写的程序，在这编写过程中，非常重要的一点就是： 要理解 tcp协议编写程序的原理，即编写服务器端的过程，以及编写客户端的过程。 只要把握这两点就可以很容易编写出来了，但是要快速编写出这个程序，那么VC6.0开发工具里，最好要安装一个番茄插件，这个插件可以快速提高你的编写程序的效率，还有也要安装msdn 文档，这样在编写过程中，遇到对某个函数的参数想不全的时候，使用msdn就能快速帮你回忆了。 呵呵，如果你那一天去面试一家牛逼的公司的哇，很有可能就是 在笔试完成之后，就要进行机试了，这就完全考查出你的真正编程水平了。 能在极短时间里完成一个socket网络程序，那么就可以令面试官感到非常满意了。 不过，这个程序，还没有连接数据库，以后再继续搞了。

       ã€€ã€€å¦‚果你去面试 深圳科技园 那家 伟易达 集团公司的软件工程师的哇，那么机试题目就是这个。 当时我去面试，首先进行笔试，面试官对我笔试成绩比较满意，所以就叫我留下来吃顿饭，下午进行机试。 当时我应聘岗位是Linux系统工程师C语言， 可是笔试题目，不但考核C，还考核C++，JavaScript，html。 我感觉好奇怪，心里想，好像我是应聘VC++开发那个岗位了。 于是我等到下午，他拿来机试题目之时，才真正明白，果然是他要安排我从事VC++开发了，题目就是：编写基于TCP/IP协议网络程序，并实现简单的聊天程序，而且要连接数据库。 当时我又失望了。 于是我就提出，我不想做这个题目，因为我是想应聘Linux系统C语言开发的。 就这样失望的走了。

       ã€€ã€€ä¸‹é¢æ˜¯ä¸ªäººå®Œå…¨èƒ½è¿è¡Œçš„代码：

       ã€€ã€€æœåŠ¡å™¨ç«¯æºç ï¼š

       ã€€ã€€#include<stdio.h>

       #include <Winsock2.h>

       #pragma comment (lib,"ws2_.lib")

       ã€€ã€€int main()

       {

        WORD wVersionRequested;

        WSADATA wsaData;

        int err;

        wVersionRequested = MAKEWORD( 2, 2 );

        err = WSAStartup( wVersionRequested, &wsaData );

        if ( err != 0 ) {

        return 0;

        }

       if ( LOBYTE( wsaData.wVersion ) != 2 ||

        HIBYTE( wsaData.wVersion ) != 2 ) {

        WSACleanup( );

        return 0;

        }

       ã€€ã€€SOCKET socketServer=socket(AF_INET,SOCK_STREAM,0);

       ã€€ã€€SOCKADDR_IN addrServer;

       ã€€ã€€addrServer.sin_family=AF_INET;

       ã€€ã€€addrServer.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

       ã€€ã€€addrServer.sin_port=htons();

       ã€€ã€€bind(socketServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr));

       ã€€ã€€listen(socketServer, 5);

       ã€€ã€€SOCKADDR_IN addrClient;

       ã€€ã€€int addrLen=sizeof(SOCKADDR_IN);

       ã€€ã€€char sendBuf[];

       ã€€ã€€char recvBuf[];

       ã€€ã€€int i=1;

        while(1)

        {

        printf("服务器端等待第%d个客户端连接请求...\n", i++);

       ã€€ã€€SOCKET newsocketServer=accept(socketServer,(struct sockaddr *)&addrClient, &addrLen);

       ã€€ã€€if(newsocketServer!=INVALID_SOCKET)

        {

        printf("服务器端与客户端连接成功...\n");

        }

       ã€€ã€€memset(sendBuf,0,);

       ã€€ã€€sprintf(sendBuf,"Welcome you to come here");

       ã€€ã€€send(newsocketServer, sendBuf, strlen(sendBuf)+1,0);

       ã€€ã€€memset(recvBuf,0,);

       ã€€ã€€recv(newsocketServer,recvBuf,,0);

       ã€€ã€€printf("服务器端收到信息:%s\n",recvBuf);

       ã€€ã€€closesocket(newsocketServer);

        }

       ã€€ã€€WSACleanup();

       ã€€ã€€return 0;

       }

       ã€€ã€€æ­¤æ–‡ç« æ¥è‡ªäºŽä¸ªäººåšå®¢ï¼š 阿浪博客 /wenxianliang@/

       ã€€ã€€å®¢æˆ·ç«¯æºç ï¼š

       ã€€ã€€#include<stdio.h>

       #include <Winsock2.h>

       #pragma comment (lib,"ws2_.lib")

       ã€€ã€€int main()

       {

        WORD wVersionRequested;

        WSADATA wsaData;

        int err;

        wVersionRequested = MAKEWORD( 2, 2 );

        err = WSAStartup( wVersionRequested, &wsaData );

        if ( err != 0 ) {

        return 0;

        }

       if ( LOBYTE( wsaData.wVersion ) != 2 ||

        HIBYTE( wsaData.wVersion ) != 2 ) {

        WSACleanup( );

        return 0;

        }

        SOCKET socketClient=socket(AF_INET,SOCK_STREAM,0);

        SOCKADDR_IN addrServer;

        addrServer.sin_family=AF_INET;

        addrServer.sin_addr.S_un.S_addr=inet_addr(".0.0.1");

        addrServer.sin_port=htons();

        char sendBuf[];

        char recvBuf[];

       ã€€ã€€printf("客户端向服务器端连接请求...\n");

       ã€€ã€€int Isconnect=connect(socketClient, (struct sockaddr *)&addrServer, sizeof(struct sockaddr));

       ã€€ã€€if(Isconnect!=0)

        {

        printf("客户端无法连接服务器端...\n");

       ã€€ã€€return 0;

        }

       ã€€ã€€printf("客户端已成功连接服务器端...\n");

       ã€€ã€€memset(recvBuf,0,);

        recv(socketClient,recvBuf,,0);

       ã€€ã€€printf("客户端收到信息:%s\n",recvBuf);

       ã€€ã€€memset(sendBuf,0,);

        sprintf(sendBuf,"Hello , I am Mr Wen !");

        send(socketClient, sendBuf, strlen(sendBuf)+1,0);

        closesocket(socketClient);

        WSACleanup();

        return 0;

       }