Windows 网络编程(7)

最新推荐文章于 2022-10-19 13:45:59 发布
最新推荐文章于 2022-10-19 13:45:59 发布
阅读量879 收藏 1
点赞数
文章标签： windows 编程 网络 socket struct buffer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/night_cat/article/details/1713803
版权

 1>Winsock初始化 (有连接)

        a>加载Winsock DLL
             int   WSAStartup  ( WORD                wVersionRepuested,   //指定准备加载的版本,
                                 LpWSADATA      lpWSAData
                                            );
            说明: 版本由宏MAKEWORD(X,Y)获得,X是高位字节(副版本),Y是低位字节(主版本),
                     LPWSADATA  结构:
                      typedef   struct   WSAData
                      {
                            WORD              wVersion,            //准备使用的Winsock版本
                            WORD              wHighVersion,        //存放现有的最高版本
                            char              szDescription[WSADESCRIPTION_LEN + 1],    //无用
                            char              szSystemStatus[WSASYS_STATUS_LEN + 1],   //无用
                            unsigned short    iMaxSockets,         //不要使用
                            unsigned  short   iMaxUdpDg,           //不要使用
                            char      FAR  *  lpVendorInfo,        //不用
                      }WSADATA,FAR* LPWSADATA;
         b>错语检查和控制
              int  WSAGetLastError (void);
         c>面向连接的协议
             i>bind
               int  bind (SOCKET                           s,
                          const struct sockaddr  FAR  *  name,
                          int                              namelen
                          );
                   例:
                            SOCKET               s;
                            struct  sockaddr_in  tcpaddr;
                            int                  port=5150;
                            s = socket( AF_INET,SOCK_STEAM,IPPROTO_TCP);
                            tcpaddr.sin_family  = AF_INET;
                            tcpaddr.sin_port = htons(port);
                            tcpaddr.sin_addr.s_addr=htonl(INADDR_ANY);
                            bind(  s, (SOCKADDR * ) &tcpaddr, sizeof(tcpaddr) );
            ii>listen
                 int listen ( SOCKET  s,
                              int     backlog   //指定正在等待连接的最大队列长度
                            );
           iii>accept  和  WSAAccept
                 SOCKET   accept  (  SOCKET                 s,         //处在监听模式的套接字
                                     struct sockaddr  FAR * addr,      //SOCKADDR_IN结构的地址,返回后包含请求方IP
                                     int    FAR *           addrlen    //SOCKADDR_IN结构的长度
                                  );     //成功后,会返回一个新套接字,与客户机沟通以后就用此新套接字
                 SOCKET   WSAAccept ( SOCKET s,
                                      struct sockaddr FAR * addr,
                                      LPINT addrlen,
                                      LPCONDITIONPROC lpfnCondition,  //函数指针(如下),根据客户请求来调用,它决定接受请求
                                      DWORD dwCallbackData);
                 说明: int CALLBACK ConditionFunc( LPWSABUF lpCallerID,  //值参数,包含连接实体的地址,
                                                   LPWSABUY lpCallerData,//随连接请求发过来的任何连接数据
                                                   LPQOS    lpSQOS,
                                                   LPQOS    lpGQOS,
                                                   LPWSABUF lpCalleeID,  //包含本地IP
                                                   LPWSABUF lpCalleeData,//对lpCallerData的补充
                                                   GROUP  FAR * g,
                                                   DWORD dwCallbackData
                                                 );

                      typedef  struct  __WSABUF
                           {
                              u_long   len;  //其值要么由buf指向的缓冲区长度,要么指定包含在缓冲区buf中的数据量
                              char FAR * buf;
                           } WSABUF,FAR * LPWSABUF;
                       说明:对 lpCallerID来说,buf指向一个地址结构如SOCKADDR类型,所以包含了客户机IP                      
         d>connect 和 WSAConnect 函数
           int connect (SOCKET s,const struct sockaddr FAR * name,int namelen)
           int WSAConnect ( SOCKET s,const struct sockaddr FAR * name,int namelen,
                            LPWSABUF lpCallerData,   //收发请求接接时的数据,包含客户机向服务器发的请求连接的数据
                            LpWSABUF lpCalleeData,   //收发请求连接时的数据,包含服务器向客户机返回的建立连接的数据
                            LPQOS    lpSQOS,
                            LPQOS    lpGQOS);
          切记,所有关系到收发数据的缓冲都属于char类型,无Unicode版本,使用Unicode时,把字符串当作char * 或造型为char * 发送
               利用字符串长度函数告诉Winsock API函数收发的数据有多少字符时,必须将这个值乘以2,另外一种就是在将字符串数据投给
               Winsock API 函数之前,用WideCharToMultiByte把UNICODE转换成ASCII码
         e>send 和 WSASend
           int send (SOCKET s,
                     const char FAR * buf,
                     int len,
                     int flags); //若成功,返回发送的字节数
           int WSASend (SOCKET      s,
                        LPWSABUF    lpBuffers, //指向一个或多个WSABUF结构的指针,
                        DWORD       dwBufferCount,   //准备投递的结构数
                        LPDWORD     lpNumberOfBytesSent,//指向DWORD(WSASend调用返回的)指针,其中包含总发送数,
                        DWORD       dwFlags,
                        LPWSAOVERLAPPED  lpOverlapped,   //用于重叠I/O
                        LPWSAOVERLappED_COMPLETION_ROUTINE  lpCompletROUTINE  //用于重叠I/O
                       );
        f>recv 和  WSARecv
          int recv( SOCKET  s,
                    char FAR * buf, //即将收到的字符缓冲,
                    int len,    //准备接收的字节数或buf缓冲的长度,
                    int flags   //0,或MSG_PEEK,MSG_OOB 或是它们的接位运算,MSG_PEEK 使数据复制到所提供的接收端缓冲,但系统还有
                  );
          int WSARecv ( SOCKET s,
                        LPWSABUF    lpBuffers,     //WSABUF 结构组成的数组
                        DWORD       dwBufferCount, //前一个数组中WSABUF结构的数目
                        LPDWORD     lpNumberOfBytesRecvd,  //指向执行这个函数调用所收到的字节数
                        lpDWORD     lpFlags,
                        LPWSAOVERLAPPED  lpOverlapped,
                        LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionROUTINE
                      );
       g>保证流式套接字所有的数据都发送出去,代码如下:
           char sendbuff[2048];
           int  nBytes = 2048,
                nLeft,
                idx;
           nLeft = nBytes;
           idx = 0;
           while (nLeft>0)
           {
             ret=send(s,&sendbuff[idx],nLeft,0);
             if (red==SOCKET_ERROR)
             { //Error}
             nLeft-=ret;
             idx +=ret;
           }
         h>中断连接
           int shutdown (SOCKET   s,  //
                            int   how  //可以是 SD_RECEIVE,SD_SEND或SD_BOTH,即不允许再调用相关函数
                        );
           int closesocket (SOCKET s);
2>例子:
        a>回应服务器代码
          #include <winsock2.h>
          #include <stdio.h>
          #define DEFAULT_PORT     5150
          #define DERAULT_bUFFER   4096

          int    port         = DEFAULT_PORT;
          BOOL   bInterface   = FALSE,
                 bRecvOnly    =FALSE;
          char   szAddress[128];
         
          void  usage()
          {
             printf ("usage: server [-p:x] [-i:IP] [-o] /n/n");
             printf ("       -p:x     port number to listen on/n");
             printf ("       -i:str  Interface to listen on/n");
             printf ("       -o      Don't echo the data back/n/n");
             ExitProcess(1);
          }
          void ValidateArgs ( int argc,char ** argv)
          {
             int i;
             for (i=1;i<argc;i++)
             {
                if ((argv[i][0]=='-')||(argv[i][0]=='/'))
                {
                   switch (tolower(argv[i][1]))
                   {
                      case 'p':
                         iPort = atoi(&argv[i][3]);
                         break;
                      case 'i':
                         bInterface = TRUE;
                         if (strlen(argv[i]>3)
                            strcpy (szAddress,&argv[i][3]);
                        break;
                      case 'o':
                         bRecvOnly = TRUE;
                         break;
                      default :
                         usage();
                         break;
                   }
                }
             }
          }

          //  线程
          DWORD  WINAPI   ClientThread ( LPVOID  lpParam )
          {
             SOCKET  sock=( SOCKET ) lpParam;
             char    szBuff[DEFAULT_BUFFER];
             int     ret,
                     nLeft,
                     idx;
           
             while (1)
             {
                ret = recv(sock,szBuff,DEFAULT_BUFFER,0);
                if (ret==0)  //正常返回(没有接收到数据)
                   break;
                else if (ret==SOCKET_ERROR)
                {
                   printf("recv() failed: %d/n",WSAGetLastError());
                   break;
                }
                szBuff[ret] = '/0';
                printf("RECV: '%s'/n",szBuff);
                //如果定义了回复
                if (! bRecvOnly)
                {
                   nLeft = ret;
                   idx = 0;
                   while (nLeft > 0)     //确保发送了所有的数据
                   {
                      ret = send (sock,&szBuff[idx],nLeft,0);
                      if (ret==0)
                         break;
                      else if (ret==SOCKET_ERROr)
                      {
                         printf ("send() failed: %d/n",WSAGetLastError());
                         break;
                      }
                      nLeft -= ret;
                      idx += ret; 
                   }
                }
             }
             return 0;
          }
          //主函数
          int  main(int argc,char ** argv)
          {
             WSADATA              wsd;
             SOCKET               sListen,
                                  sClient;
             int                  iAddrSize;
             HANDLE               hThread;
             DWORD                dwThreadID;
             struct sockaddr_in   local,
                                  client;
            
             ValidateArgs (argc,argv);
             if (WSAStartup(MAKEWORD(2,2),&wsd)!=0)
             {
                printf ("Failed to load Winsock!/n");
                return 1;
             }
            
             slisten = socket (AF_INET,SOCK_STREAM,IPPROTO_IP);
             if (sListen==SOCKET_ERROR)
             {
                printf (" socket() failed:%d/n",WSAGetLastError());
                return 1;
             }
            
             if (bInterface)
             {
                local.sin_addr.s_addr = inet_addr(szAddress);
                if (local.sin_addr.s_addr==INADDR_NONE)
                { usage();}
             }
             else
                local.sin_addr.s_addr = htonl(INADDR_ANY);
             local.sin_family = AF_INET;
             local.sin_port   = htons(iPort);

             if (bind(sListen,(struct sockaddr *)&local,sizeof(local))==SOCKET_ERROR)
             {
                printf ("bind() failed:%d/n",WSAGetLastError());
                return 1;
             }
             listen (sListen,8);
            
             while (1)
             {
                iAddrSize = sizeof(client);
                sClient = accept (sListen,(struct sockaddr *)&client,&iAddrSize);
                if (sClient == INVALID_SOCKET)
                {
                   printf ("accept() failed: %d/n",WSAGetLastError());
                   break;
                }
                printf("Accepted client: %s:%d/n",inet_ntoa(client.sin_addr),ngohs(client.sin_port));
 
                hThread = CreateThread (NULL,0,ClientThread,(LPVOID)sClient,0,&dwThreadID);
                if (hThread ==NULL)
                {
                   printf("CreatThread() failed:%d/n",GetLastError());
                   break;
                }
                CloseHandle(hThread);
             }
             closesocket(sListen);
            
             WSACleanup();
             return 0;
          }
   ///      

       b>客户机代码
          #include <winsock2.h>
          #include <stdio.h>
          #include <stdlib.h>
 
          #define  DEFAULT_COUNT     20
          #define  DEFAULT_PORT      5150
          #define  DEFAULT_BUFFER    2048
          #define  DEFAULT_MESSAGE   "This is a test of the emergency / broadcasting system"

          char     szServer[128],
                   szMessage[1024];   //向服务器发送的信息
          int      iPort     = DEFAULT_PORT;
          DWORD    dwCount   = DEFAULT_COUNt;
          BOOL     bSendOnly = FALSE;   //只发不收标志
         
          void  usage()
          {
             printf ("usage: client [-p:x] [-s:IP] [-n:x] [-o] /n/n");
             printf ("       -p:x     Remote port to send to/n");
             printf ("       -s:IP    Server's IP address or host name/n");
             printf ("       -n:x     Number of timer to send message/n");
             printf ("       -o       Send message only;Don't receive/n");
             ExitProcess(1);
          }
         
          void ValidateArgs ( int argc,char ** argv)
          {
             int i;
             for (i=1;i<argc;i++)
             {
                if ((argv[i][0]=='-')||(argv[i][0]=='/'))
                {
                   switch (tolower(argv[i][1]))
                   {
                      case 'p':
                         if (strlen(argv[i])>3)
                            iPort = atoi(&argv[i][3]);
                         break;
                      case 's':
                         if (strlen(argv[i]>3)
                            dwCount = atoi(&argv[1][3]);
                        break;
                      case 'o':
                         bSendOnly = TRUE;
                         break;
                      default :
                         usage();
                         break;
                   }
                }
             }
          }
         
          int main( int argc,char **argv)
          {
             WSADATA     wsd;
             SOCKET      sClient;
             char        szBuffer[DEFAULT_BUFFER];
             int         ret,
                         i;
             struct sockaddr_in   server;
             struct hostent       *host = NULL;
            
             ValidateArgs( argc,argv);
             if (WSAStartup(MAKEWORD(2,2),&wsd)!=0)
             {
                 printf ("Failed to load Winsock librarv!/n");
                 return i;
             }
             strcpy( szMessage,DEFAULT_MESSAGE);

             sClient = socket (AF_INET,SOCk_STREAM,IPPROTO_TCP);
             if (sClient == INVALID_SOCKET)
             {
                 printf ("socket() failed:%d/n",GETLastError());
                 return 1;
             }
             server.sin_family       = AF_INET;
             server.sin_port         = htons(iPort);
             server.sin_addr.s_addr  = inet_addr(szServer);
            
             if(server.sin_addr.s_addr == INADDR_NONE)
             {
                 host = gethostbyname (szServer);
                 if (host==NULL)
                 {
                    printf ("Unable to resolve server: %s/n",szServer);
                    return 1;
                 }
                 CopyMemory (&server.sin_addr,host->h_addr_list[0],host->h_length);
             }
             if (connect (sClient,(struct sockaddr * )&server,sizeof(server)) == SOCKET_ERROR)
             {
                //Error
             }
            
             for (i=0;i<dwCount;i++)
             {
                 ret = send (sClient,szMessage,strlen(szMessage),0);
                 if (ret==0) { break;}
                 else if (ret ==SOCKET_ERROR)
                 {
                     //Error
                 }
                 printf ("Send %d bytes/n",ret);
                 if (!bSendOnly)
                 {
                     ret =recv (sClient,szBuffer,DefAULT_BUFFER,0);
                     if (ret ==0)  {break;}
                     else if (ret ==SOCKET_ERROR)  {//Error}
                 }
                 szBuffer[ret]='/0';
                 printf ("RECV [%d bytes]:'%s'/n",ret,szBuffer);
             }
             closesocket (sClient);
            
             WSACleanup();
             return 0;
          }
3.无连接协议
    i>无需listen和accept,只接接收和发送
      int recvfrom (SOCKET s,
                    char  FAR* buf,
                    int    len,
                    int    flags,
                    struct sockaddr FAR * from,
                    int FAR * fromlen
                   );
      int WSARecvFrom (SOCKET s,
                       LPWSABUF lpBuffers,    //缓冲数组指针
                       DWORD    dwBufferCount,   // 指定包含的缓冲数
                       LPDWORD  lpNumberOfBytesRecvd,   //返回读取的字节总数
                       LPDWORD  lpFlags,
                       struct  sockaddr FAR * lpFrom,    //包含发送方的IP
                       LPINT lpFromlen,                  //SOCKADDR结构的长充
                       LPWSAOVERLAPPED lpOverlapped,
                       LPWSAOVERLAPPED_COMPLETION_ROUTINE  lpCompletionROUTINE
                      );
      int sendto( SOCKET s,
                  const char FAR* buf,
                  int len,
                  int flags,
                  const struct sockaddr FAR * to,
                  int tolen
                )
      int WSASendTo (SOCKET s,
                     LPWSABUF  lpBuffers,
                     DWORD dwBufferCount,
                     LPDWORD lpNumberOfBytesSent,   //真正发送的字节数
                     DWORD dwFlags,
                     const struct sockaddr FAR * lpTo,
                     int itolen,
                     LPWSAOVERLAPPED lpOverlapped,
                     LPWSAOVERLAPPED_COMpLETION_ROUTINE lpCompletionROUTINE
                    )
4>无连接的例
     i>接收端 
      #include <winsock2.h>
      #include <stdio.h>
      #include <stdlib.h>

      #define  DEFAULT_PORT                   5150
      #define  DEFAULT_COUNT                  25
      #define  DEFAULT_BUFFER_LENGTH          4096
     
      int     iPort     =DEFAULT_PORT;
      DWORD   dwCount   =DEFAULT_COUNT,
              dwLength  =DEFAULT_BUFFER_LENGTH;
      BOOL    bInterface =FALSE;

      char    szInterface[32];

      void usage()
      {
          printf ("usage:sender [-p:int] [-i:IP] [-n:x] [-b:x]/n/n");
          printf ("             -p:int  Local prot/n");
          printf ("             -i:IP   Local IP address to listen on/n");
          printf ("             -n:x    Number of times to send message/n");
          printf ("             -b:x    Size of buffer jto send/n/n");
          ExitProcess (1);
      }
     
      void ValidateArgs(int argc,char** argv)
      {
          int              i;
         
          for (i=1;i<argc;i++)
          {
             if ((argv[i][0]=='-')||(argv[i][0])=='/')
             {
                switch (tolower(argv[i][1]))
                {
                   case 'p':          //Local port
                      if (strlen(argv[i])>3)
                         iPort=atoi(&argv[i][3]);
                      break;
                   case 'n':
                      if(strlen(argv[i])>3)
                         dwLength = atoi(&argv[i][3]);
                      break;
                   case 'i':
                      if (strlen(argv[i])>3)
                      {
                          bInterface = TRUE;
                          strcpy(szInterface,&argv[i][3]);
                      }
                      break;
                   default:
                      usage();
                      break;
                }
             }
          }
      }

      int  main (int argc,char ** argv)
      {
          WSADATA             wsd;
          SOCKET              s;
          char                *recvbuf = NULL;
          int                 ret,
                              i;
          DWORD               dwSenderSize;
          SOCKADDR_IN         sender,
                              local;

          ValidateArgx(argc,argv);
          if (WSAStartup (MAKEWORD(2,2),&wsd)!=0)
          {
             //Error
          }
         
          s = socket(AF_INET,SOCK_DGRAM,0);
          if (s==INVALID_SOCKET)
          {  //Error  }
         
          local.sin_family = AF_INET;
          local.sin_port   = htons((short)iPort);
          if (bInterface)
             local.sin_addr.s_addr  = inet_addr(szInterface);
          else
             local.sin_addr.s_addr  = htonl(INADDR_ANY);
         
          if (bind(s,(SOCKADDR *)&local,sizeof(local))==SOCKET_ERROR)
          {  //Error  }
         
          recvbuf = GlobalAlloc(GMEM_FIXED,dwLength);
          if (!recvbuf)
          {   //Error  }
         
          for (i=0,i<dwCount;i++)
          {
              dwSenderSize = sizeof(sender);
              ret = recvfrom(s,recvbuf,dwLength,0,(SOCKADDR*)&sender,&dwSenderSize);
              if (ret == SOCKET_ERROR)  {  //Error  }
              else if (ret==0)  {break;}
              else
              {
                 recvbuf[ret]='/0';
                 printf("[%s] sent me: '%s'/n",inet_ntoa(sender.sin_addr),recvbuf);
              }
          }
          closesocket(s);
          GlobalFree(recvbuf);
          WSACleanup();
          return 0; 
      }
     ii>无连接的  发送端
      #include  <winsock2.h>
      #include  <stdio.h>
      #include  <stdlib.h>

      #define   DEFAULT_PORT            5150
      #define   DEFAULT_COUNT           25
      #define   DEFAULT_CHAR            'a'
      #define   DEFAULT_BUFFER_LENGTH   64

      BOOL      bConnect = FALSE;
      int       iPort    = DEFAULT_PORT;
      char      cChar    = DEFAULT_CHAR;
      DWORD     dwCount  = DEFAULT_COUNT;
                dwLength = DEFAULT_BUFFER_LENGTH;
      char      szRecipient[128];

      void usage()
      {
          printf("");
          printf("");
          printf("");
          printf("");
          printf("");
          printf("");
          printf("");
          ExitProcess(1);
      }

      void ValidateArgs(int argc,char ** argv)
      {
          int            i;
          for(i=1;i<argc;i++)
          {
              if((argv[i][0]=='-')||(argv[i][0]=='/'))
              {
                 switch (tolower(argv[i][1]))
                 {
                    case 'p':
                       if(strlen(argv[i])>3)
                          iPort = atoi(&argv[i][3]);
                       break;
                    case 'r':
                       if(strlen(argv[i])>3)
                          strcpy(szRecipient,&argv[i][3]);
                       break;
                    case 'c':
                       if(strlen(argv[i])>3)
                          dwCount = atoi(&argv[i][3]);
                       break;
                    case 'b':
                       if(strlen(argv[i])>3)
                          dwLength = atoi(&argv[i][3])
                       break;
                    default:
                       usage();
                       break;
                 }
              }
          }
      }

      int main(int argc,char** argv)
      {
          WSADATA               wsd;
          SOCKET                s;
          char                  *sendbuf = NULL;
          int                   ret,
                                i;
          SOCKADDR_IN           recipient;
         
          validateArgs(argc,argv);
          if (WSAStarup(MAKEWORD(2,2),&wsd)!=0)
          {  //Error  }
         
          s = socket(AF_INET,SOCK_DGRAM,0);
          if(s==INVALID_SOCKET)    {  //Error }
         
          recipient.sin_family = AF_INET;
          recipient.sin_port   = htons((short)iProt);
          if ((recipient.sin_addr.s_addr =  inet_addr(szRecipient))==INADDR_NONE)
          {
             struct hostent *hosts=NULL;

             host = gethostbyname(szRecipient);
             if(host)
                CopyMemory(&recipient.sin_addr,host->h_addr_list[0],host->h_length);
             else
             {
                printf("gethostbyname() failed: %d/n",WSAGetLastError());
                WSAClearup();
                return 1;
             }
           }

           sendbuf = GlobalAlloc(GMEM_FIXED,dwLength);
           if(!sendbuf)
           {  //Error  }
           memset(sendbuf,cChar,dwLength);
          
           if (bConnect)
           {
               if(connect(s,(SOCKADDR*)&recipient,sizeof(recipient))==SOCKET_ERROR)
               {
                  printf("");
                  GlobalFree(sendbuf);
                  WSACleanup();
                  return 1;
               }
               for(i=0;i<dwCount;i++)
               {
                 ret = send(s,sendbuf,dwLength,0);
                 if (ret=SOCKET_ERROR) 
                    {//  Error  }
                 else if (ret==0)
                    break;
               }
           }
           else
           {
               for(i=0;i<dwCount;i++)
               {
                   ret = sendto(s,sendbuf,dwLength,0,(SOCKADDR*)&recipient,sizeof(recipient));
                   if (ret == SOCKET_ERROR)
                   {   //Error  }
                   else if (ret==0)
                      break;
               }
           }
           closesocket(s);
           GlobalFree(sendbuf);
           WSACleanup();
           return 0;
      }
5> 其它 API 函数

      i>  int getpeername(SOCKET  s,     //准备连接的套接字
                          struct sockaddr FAR* name,
                          int  FAR* namelen
                          );//获得通信方的套接字地址信息,对数据报来说,是连接调用的地址,而不是sendto地址 
      ii> int getsockname(SOCKET  s,
                          struct  sockaddr FAR* name,
                          int FAR* namelen
                         );  //返回指定套接字的本地接口信息

night_cat
关注
Windows网络编程.pdf
09-30
Windows 网络编程 概述 Windows 网络编程是指在 Windows 操作系统平台上进行网络编程的技术，涉及到 Windows Socket、网络协议、网络应用程序的开发等方面。 Windows 网络编程的主要目的是实现高性能的网络应用...
socket编程在windows和linux下的区别＜转载＞
最新发布
weixin_42137483的博客
11-09 657
如无其它说明，本文所指Linux均表示2.6内核Linux，GCC编译器，Windows均表示Windows XP系统，Visual Studio 2005 sp1编译环境。以下来自转载下面大概分几个方面进行罗列：Linux要包含[cpp]等头文件，而windows下则是包含。Linux中socket为整形，Windows中为一个SOCKET。Linux中关闭socket为close，Windows中为closesocket。
Windows网络编程附书代码(简单的服务器与客户端)
劉俊的专栏
01-29 5049
//程序清单6-1 回应服务器代码 // 编译命令Compile：cl -o Server Server.c ws2_32.lib // // 命令行选项： // server [-p:x] [-i:IP] [-o] // -p:x 监听的端口号 // -i:str 监听的网卡 // -o 只接收，不回显数据 // #include #include #inc
c语言 socket和winsock,SOCKET programming(C语言 winsock)
weixin_33377602的博客
05-19 201
SOCKET programming：1．clientbasic algorithm：(1)。Find the address of the server (IP+PORT);(2)。Using SOCKET call to create the socket；(3)。Get the local port numberusing CONNECTcall ;(4)。Connect the clie...
多线程编程实例----服务器客户端简单通信
浪的专栏
07-07 716
    这是一个非常简单的通信程序，不需要什么前奏来说明这个问题，可以直接来看程序的实现，首先是服务器端的程序：int main(int argc, char **argv){ WSADATA wsd; SOCKET sListen, sClient; int iAddrSize; HANDLE hThread; DWORD dwThread; struct sockaddr_
Windows网络编程 杨秋黎 课后习题答案.pdf
07-04
在介绍知识点之前，需要明确一点：Windows网络编程是一个比较广泛的领域，涵盖了很多基础概念和高级技巧，而提供的文件内容仅涉及到IP地址和子网掩码相关的一些习题答案。因此，以下内容将主要围绕IP地址分类、子网...
Windows Sockets网络编程
11-07
《Windows Sockets网络编程》分为三部分：第一部分（第1～6章），提供了翔实的背景知识和框架方面的概念，借助于此框架，读者可理解WinSock的具体细节，包括Windows Sockets概述、OSI网络参考模型、TCP/IP协议簇中的...
Windows 网络编程1
03-19
"Windows网络编程1"可能涉及的是对Windows API的深入理解和应用，尤其是关于网络通信的部分。本篇文章将探讨Windows网络编程的一些核心概念、API以及相关工具，帮助读者理解如何在Windows平台上进行网络开发。 首先...
winsock recv函数使用注意
是我
08-12 3863
Winsock int recv( SOCKET s, char FAR *buf, int len, int flags 支持MSG_WAITALL ); 在使用这个函数的时候为了能够一次性接收客户端的封包,我尝试使用了MSG_WAITALL的标志,但是这个标志使用上竟然有点奇怪,网上资料也相对比较少,最后在
windows网络编程入门
CppPlayer
04-12 1291
windows Sockets 的版本： 头文件：WINSOCK.h 库文件：wsock32.lib 动态困：WINSOCK.DLL 头文件：WINSOCK2.h 库文件：WS2_32.lib 动态困：WS2_32.DLL 服务端： WSADATA wsd; //WSADATA变量 SOCKET sServer; //服务器套接字 SOCKET
c语言实现ftp下载步骤,FTP客户端和服务器源代码(C语言)实现
weixin_29104059的博客
05-18 790
课程设计：FTP的设计与实现/****************client.c****************/#include #include #include #pragma comment(lib,"ws2_32.lib")#define DEFAULT_PORT 2302#define DEFAULT_BUFFER 2048#define DEFAULT_MESS...
使用阻塞模式写的一个带命令行Socket服务器代码
castmoon的专栏
03-12 630
 #include "stdafx.h"#include #include #define PORT 5150#define DATA_BUFSIZE 4096#define SEND_COUNT   10DWORD g_dwPort = 1234;char g_szServer[64] = {0};BOOL g_bSend = FALSE;BOOL g_bRecv = FALSE;D
nread c语言,Ping 源代码-C语言
weixin_42469444的博客
05-19 177
#include "winsock2.h" #include "ws2tcpip.h" #include "stdio.h" #include "stdlib.h" #include "windows.h"#define IP_RECORD_ROUTE 0x7 #define WIN32_LEAN_AND_MEAN#pragma comment (lib,"ws2_32.lib")typedef...
TCP_IP
m0_52331372的博客
10-19 1378
TCP_IP
理解 void main(int argc, char** argv)
panda的专栏
12-11 1103
理解 void main(int argc, char** argv)这个函数搞个两星号，看上去就复杂了点儿，如果改成这样就感觉熟悉的了许多void main(int argc, char* argv[ ]) void main(int argc, char* argv[ ])等同于void main(int argc, char* *argv)这行中有三个字符串分别为 cp.ex
关于int main( int argc, char* argv[] ) 中arg和argv参数的解析及调试
热门推荐
一树荼蘼的博客
07-10 12万+
在示例程序中经常可以看到argc和argv这两个参数 ，在调试代码过程中遇到main函数为int main( int argc, char* argv[] ) 这种类型时往往会报错，或者是运行起来了但命令窗口一闪而过，没有出来结果。网上关于这方面的资料也有点乱，在看浅墨大大一书发现其中有关于这一方面的讲解甚为详细，抑制不住要与大家分享的冲动，现结合网上内容并予以实验，整理如下： ...
C主函数：void main(int argc,char *argv[] )
weixin_30497527的博客
05-06 219
这主函数的形参乍一看略抽象啊，什么意思？主函数还有参数了？ 这是用来在命令行里传递参数用的！ argc 记录命令行参数个数（以间隔为界，不含间隔）；*argv[] 是个指针数组，分别指向每个参数。 例如：在命令行执行 a.exe username password ，则 argc 等于 3 ， argv[0] 为 “a.exe” argv[1] 为 “username” argv[2...
Windows网络编程实战指南
"《WINDOWS网络编程技术.pdf》是一本专注于Windows平台网络编程的书籍，涵盖了从基础知识到高级技术的全面讲解。作者深入浅出地介绍了如何在Windows 95/98/NT 4/2000/CE等多个版本上进行网络编程，包括NetBIOS、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值