游戏开发论坛

 找回密码
 立即注册
搜索
查看: 3148|回复: 2

无题

[复制链接]

17

主题

1629

帖子

5982

积分

论坛元老

Rank: 8Rank: 8

积分
5982
QQ
发表于 2015-12-18 10:43:53 | 显示全部楼层 |阅读模式
  1. #include <winsock2.h>
  2. #include <stdio.h>

  3. int Socket(int family, int type, int protocol)
  4. {
  5.         int n;

  6.         if ((n = socket(family, type, protocol)) < 0)
  7.         {
  8.                 fputs("socket error", stderr);
  9.         }

  10.         return(n);
  11. }

  12. void Connect(int fd, const struct sockaddr *sa, int salen)
  13. {
  14.         if (connect(fd, sa, salen) < 0)
  15.         {
  16.                 fputs("connect error", stderr);
  17.         }
  18. }

  19. void Send(int fd, const void *ptr, size_t nbytes, int flags)
  20. {
  21.         if (send(fd, (const char*)ptr, nbytes, flags) != nbytes)
  22.         {        
  23.                 fputs("send error", stderr);
  24.         }
  25. }

  26. void Bind(int fd, const struct sockaddr *sa, int salen)
  27. {
  28.         if (bind(fd, sa, salen) < 0)
  29.         {
  30.                 fputs("bind error", stderr);
  31.         }
  32. }

  33. void Listen(int fd, int backlog)
  34. {
  35.         if (listen(fd, 5) < 0)
  36.         {
  37.                 fputs("listen error", stderr);
  38.         }
  39. }

  40. int Accept(int fd, struct sockaddr *sa, int *salenptr)
  41. {
  42.         int        n;
  43. again:

  44.         if ((n = accept(fd, sa, salenptr)) < 0)
  45.         {
  46.                 if (GetLastError() == WSAECONNABORTED)
  47.                 {
  48.                         goto again;
  49.                 }
  50.                 else
  51.                 {
  52.                         fputs("accept error", stderr);
  53.                 }
  54.         }

  55.         return(n);
  56. }

  57. int Select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
  58. {
  59.         int n;

  60.         if ((n = select(nfds, readfds, writefds, exceptfds, timeout)) < 0)
  61.         {
  62.                 int err = WSAGetLastError();
  63.                 fputs("select error", stderr);
  64.         }

  65.         return(n);                /* can return 0 on timeout */
  66. }

  67. char* Fgets(char *ptr, int n, FILE *stream)
  68. {
  69.         char* rptr;

  70.         if ((rptr = fgets(ptr, n, stream)) == NULL && ferror(stream))
  71.         {
  72.                 fputs("fgets error", stderr);
  73.         }

  74.         return (rptr);
  75. }

  76. void Fputs(const char *ptr, FILE *stream)
  77. {
  78.         if (fputs(ptr, stream) == EOF)
  79.         {
  80.                 fputs("fputs error", stderr);
  81.         }
  82. }

  83. int writen(int fd, const void *vptr, size_t n)
  84. {
  85.         size_t nleft;
  86.         int        nwritten;
  87.         const char* ptr;

  88.         ptr = (const char*)vptr;
  89.         nleft = n;

  90.         while (nleft > 0)
  91.         {
  92.                 if ((nwritten = send(fd, ptr, nleft, 0)) <= 0)
  93.                 {
  94.                         if (nwritten < 0 && WSAGetLastError() == WSAEINTR)
  95.                         {
  96.                                 nwritten = 0; /* and call write() again */
  97.                         }
  98.                         else
  99.                         {
  100.                                 return(-1);        /* error */
  101.                         }
  102.                 }

  103.                 nleft -= nwritten;
  104.                 ptr += nwritten;
  105.         }

  106.         return(n);
  107. }

  108. void Writen(int fd, void *ptr, size_t nbytes)
  109. {
  110.         if (writen(fd, ptr, nbytes) != nbytes)
  111.         {
  112.                 fputs("writen error", stderr);
  113.         }
  114. }

  115. static int        read_cnt;
  116. static char        *read_ptr;
  117. static char        read_buf[1024];

  118. static int my_read(int fd, char *ptr)
  119. {
  120.         if (read_cnt <= 0)
  121.         {
  122. again:
  123.                 if ((read_cnt = recv(fd, read_buf, sizeof(read_buf), 0)) < 0)
  124.                 {
  125.                         if (WSAGetLastError() == WSAEINTR)
  126.                         {
  127.                                 goto again;
  128.                         }

  129.                         return(-1);
  130.                 }
  131.                 else if (read_cnt == 0)
  132.                 {
  133.                         return(0);
  134.                 }

  135.                 read_ptr = read_buf;
  136.         }

  137.         read_cnt--;
  138.         *ptr = *read_ptr++;
  139.         return(1);
  140. }

  141. int readline(int fd, void *vptr, size_t maxlen)
  142. {
  143.         int        n, rc;
  144.         char c, *ptr;

  145.         ptr = (char*)vptr;

  146.         for (n = 1; n < maxlen; n++)
  147.         {
  148.                 if ((rc = my_read(fd, &c)) == 1)
  149.                 {
  150.                         *ptr++ = c;

  151.                         if (c == '\n')
  152.                         {
  153.                                 break; /* newline is stored, like fgets() */
  154.                         }
  155.                 }
  156.                 else if (rc == 0)
  157.                 {
  158.                         *ptr = 0;
  159.                         return(n - 1); /* EOF, n - 1 bytes were read */
  160.                 }
  161.                 else
  162.                 {
  163.                         return(-1);        /* error, errno set by read() */
  164.                 }
  165.         }

  166.         *ptr = 0; /* null terminate like fgets() */
  167.         return(n);
  168. }

  169. int readlinebuf(void **vptrptr)
  170. {
  171.         if (read_cnt)
  172.         {
  173.                 *vptrptr = read_ptr;
  174.         }

  175.         return(read_cnt);
  176. } /* end readline */

  177. int Readline(int fd, void *ptr, size_t maxlen)
  178. {
  179.         int        n;

  180.         if ((n = readline(fd, ptr, maxlen)) < 0)
  181.         {
  182.                 fputs("readline error", stderr);
  183.         }

  184.         return(n);
  185. }

  186. void Close(int fd)
  187. {
  188.         if (closesocket(fd) == -1)
  189.         {
  190.                 fputs("close error", stderr);
  191.         }
  192. }

  193. void str_echo(int sockfd)
  194. {
  195.         int        n;
  196.         char buf[1024];

  197. again:
  198.         while ((n = recv(sockfd, buf, 1024, 0)) > 0)
  199.         {
  200.                 Writen(sockfd, buf, n);
  201.         }

  202.         if (n < 0 && WSAGetLastError() == WSAEINTR)
  203.         {        
  204.                 goto again;
  205.         }
  206.         else if (n < 0)
  207.         {
  208.                 fputs("str_echo: read error", stderr);
  209.         }
  210. }

  211. int main()
  212. {
  213.         WSAData wsaData;
  214.         WSAStartup(MAKEWORD(2, 2), &wsaData);

  215.         int        i, maxi, maxfd, listenfd, connfd, sockfd;
  216.         int        nready, client[FD_SETSIZE];
  217.         int n;
  218.         fd_set rset, allset;
  219.         char buf[1024];
  220.         int        clilen;
  221.         struct sockaddr_in        cliaddr, servaddr;

  222.         listenfd = Socket(AF_INET, SOCK_STREAM, 0);

  223.         servaddr.sin_family = AF_INET;
  224.         servaddr.sin_port = htons(9877);
  225.         servaddr.sin_addr.s_addr = INADDR_ANY;

  226.         Bind(listenfd, (sockaddr*)&servaddr, sizeof(servaddr));
  227.         Listen(listenfd, 5);

  228.         maxfd = listenfd; /* initialize */
  229.         maxi = -1; /* index into client[] array */
  230.         
  231.         for (i = 0; i < FD_SETSIZE; i++)
  232.         {
  233.                 client[i] = -1;        /* -1 indicates available entry */
  234.         }

  235.         FD_ZERO(&allset);
  236.         FD_SET(listenfd, &allset);

  237.         for (;;)
  238.         {
  239.                 rset = allset; /* structure assignment */
  240.                 nready = Select(maxfd+1, &rset, NULL, NULL, NULL);

  241.                 if (FD_ISSET(listenfd, &rset))
  242.                 {        /* new client connection */
  243.                         clilen = sizeof(cliaddr);
  244.                         connfd = Accept(listenfd, (sockaddr*) &cliaddr, &clilen);

  245.                         for (i = 0; i < FD_SETSIZE; i++)
  246.                         {
  247.                                 if (client[i] < 0)
  248.                                 {
  249.                                         client[i] = connfd;        /* save descriptor */
  250.                                         break;
  251.                                 }
  252.                         }
  253.                                 
  254.                         if (i == FD_SETSIZE)
  255.                         {
  256.                                 fputs("too many clients", stderr);
  257.                         }

  258.                         FD_SET(connfd, &allset); /* add new descriptor to set */

  259.                         if (connfd > maxfd)
  260.                         {
  261.                                 maxfd = connfd; /* for select */
  262.                         }

  263.                         if (i > maxi)
  264.                         {
  265.                                 maxi = i; /* max index in client[] array */
  266.                         }

  267.                         if (--nready <= 0)
  268.                         {
  269.                                 continue; /* no more readable descriptors */
  270.                         }        
  271.                 }

  272.                 for (i = 0; i <= maxi; i++)
  273.                 {        /* check all clients for data */
  274.                         if ((sockfd = client[i]) < 0)
  275.                         {
  276.                                 continue;
  277.                         }

  278.                         if (FD_ISSET(sockfd, &rset))
  279.                         {
  280.                                 if ((n = recv(sockfd, buf, 1024, 0)) == 0)
  281.                                 {
  282.                                         /*4connection closed by client */
  283.                                         Close(sockfd);
  284.                                         FD_CLR(sockfd, &allset);
  285.                                         client[i] = -1;
  286.                                 }
  287.                                 else
  288.                                 {
  289.                                         Writen(sockfd, buf, n);
  290.                                 }

  291.                                 if (--nready <= 0)
  292.                                 {
  293.                                         break; /* no more readable descriptors */
  294.                                 }
  295.                         }
  296.                 }
  297.         }
  298. }
复制代码

17

主题

1629

帖子

5982

积分

论坛元老

Rank: 8Rank: 8

积分
5982
QQ
 楼主| 发表于 2015-12-18 10:46:02 | 显示全部楼层
本帖最后由 __BlueGuy__ 于 2015-12-25 10:04 编辑
  1. #include <winsock2.h>
  2. #include <stdio.h>

  3. int Socket(int family, int type, int protocol)
  4. {
  5.         int n;

  6.         if ((n = socket(family, type, protocol)) < 0)
  7.         {
  8.                 fputs("socket error", stderr);
  9.         }

  10.         return(n);
  11. }

  12. void Connect(int fd, const struct sockaddr *sa, int salen)
  13. {
  14.         if (connect(fd, sa, salen) < 0)
  15.         {
  16.                 fputs("connect error", stderr);
  17.         }
  18. }

  19. void Send(int fd, const void *ptr, size_t nbytes, int flags)
  20. {
  21.         if (send(fd, (const char*)ptr, nbytes, flags) != nbytes)
  22.         {        
  23.                 fputs("send error", stderr);
  24.         }
  25. }

  26. char* Fgets(char *ptr, int n, FILE *stream)
  27. {
  28.         char* rptr;

  29.         if ((rptr = fgets(ptr, n, stream)) == NULL && ferror(stream))
  30.         {
  31.                 fputs("fgets error", stderr);
  32.         }

  33.         return (rptr);
  34. }

  35. void Fputs(const char *ptr, FILE *stream)
  36. {
  37.         if (fputs(ptr, stream) == EOF)
  38.         {
  39.                 fputs("fputs error", stderr);
  40.         }
  41. }

  42. int writen(int fd, const void *vptr, size_t n)
  43. {
  44.         size_t nleft;
  45.         int        nwritten;
  46.         const char* ptr;

  47.         ptr = (const char*)vptr;
  48.         nleft = n;

  49.         while (nleft > 0)
  50.         {
  51.                 if ((nwritten = send(fd, ptr, nleft, 0)) <= 0)
  52.                 {
  53.                         if (nwritten < 0 && WSAGetLastError() == WSAEINTR)
  54.                         {
  55.                                 nwritten = 0; /* and call write() again */
  56.                         }
  57.                         else
  58.                         {
  59.                                 return(-1);        /* error */
  60.                         }
  61.                 }

  62.                 nleft -= nwritten;
  63.                 ptr += nwritten;
  64.         }

  65.         return(n);
  66. }

  67. void Writen(int fd, void *ptr, size_t nbytes)
  68. {
  69.         if (writen(fd, ptr, nbytes) != nbytes)
  70.         {
  71.                 fputs("writen error", stderr);
  72.         }
  73. }

  74. static int        read_cnt;
  75. static char        *read_ptr;
  76. static char        read_buf[1024];

  77. static int my_read(int fd, char *ptr)
  78. {
  79.         if (read_cnt <= 0)
  80.         {
  81. again:
  82.                 if ((read_cnt = recv(fd, read_buf, sizeof(read_buf), 0)) < 0)
  83.                 {
  84.                         if (WSAGetLastError() == WSAEINTR)
  85.                         {
  86.                                 goto again;
  87.                         }

  88.                         return(-1);
  89.                 }
  90.                 else if (read_cnt == 0)
  91.                 {
  92.                         return(0);
  93.                 }

  94.                 read_ptr = read_buf;
  95.         }

  96.         read_cnt--;
  97.         *ptr = *read_ptr++;
  98.         return(1);
  99. }

  100. int readline(int fd, void *vptr, size_t maxlen)
  101. {
  102.         int        n, rc;
  103.         char c, *ptr;

  104.         ptr = (char*)vptr;

  105.         for (n = 1; n < maxlen; n++)
  106.         {
  107.                 if ((rc = my_read(fd, &c)) == 1)
  108.                 {
  109.                         *ptr++ = c;

  110.                         if (c == '\n')
  111.                         {
  112.                                 break; /* newline is stored, like fgets() */
  113.                         }
  114.                 }
  115.                 else if (rc == 0)
  116.                 {
  117.                         *ptr = 0;
  118.                         return(n - 1); /* EOF, n - 1 bytes were read */
  119.                 }
  120.                 else
  121.                 {
  122.                         return(-1);        /* error, errno set by read() */
  123.                 }
  124.         }

  125.         *ptr = 0; /* null terminate like fgets() */
  126.         return(n);
  127. }

  128. int readlinebuf(void **vptrptr)
  129. {
  130.         if (read_cnt)
  131.         {
  132.                 *vptrptr = read_ptr;
  133.         }

  134.         return(read_cnt);
  135. } /* end readline */

  136. int Readline(int fd, void *ptr, size_t maxlen)
  137. {
  138.         int        n;

  139.         if ((n = readline(fd, ptr, maxlen)) < 0)
  140.         {
  141.                 fputs("readline error", stderr);
  142.         }

  143.         return(n);
  144. }

  145. void str_cli(FILE *fp, int sockfd)
  146. {
  147.         char sendline[1024], recvline[1024];

  148.         while (Fgets(sendline, 1024, fp) != NULL)
  149.         {
  150.                 Writen(sockfd, sendline, strlen(sendline));

  151.                 if (Readline(sockfd, recvline, 1024) == 0)
  152.                 {
  153.                         exit(0);
  154.                 }

  155.                 Fputs(recvline, stdout);
  156.         }
  157. }

  158. int main()
  159. {
  160.         WSAData wsaData;
  161.         WSAStartup(MAKEWORD(2, 2), &wsaData);

  162.         int sockfd;
  163.         struct sockaddr_in servaddr;

  164.         sockfd = Socket(AF_INET, SOCK_STREAM, 0);

  165.         servaddr.sin_family = AF_INET;
  166.         servaddr.sin_port = htons(9877);
  167.         struct hostent *host_entry = gethostbyname("localhost");
  168.         servaddr.sin_addr.s_addr = *(unsigned long*) host_entry->h_addr;

  169.         Connect(sockfd, (sockaddr*)&servaddr, sizeof(servaddr));

  170.         str_cli(stdin, sockfd);

  171.         return 0;
  172. }
复制代码

17

主题

1629

帖子

5982

积分

论坛元老

Rank: 8Rank: 8

积分
5982
QQ
 楼主| 发表于 2015-12-22 10:23:42 | 显示全部楼层
本帖最后由 __BlueGuy__ 于 2015-12-25 10:05 编辑

其实,我就是抄一下代码
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

作品发布|文章投稿|广告合作|关于本站|游戏开发论坛 ( 闽ICP备17032699号-3 )

GMT+8, 2025-2-25 14:02

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表