网络编程之socket编程实例

  1 #include <sys/types.h>  
  2 #include <sys/socket.h>                         // 包含套接字函数库  
  3 #include <stdio.h>  
  4 #include <netinet/in.h>                         // 包含AF_INET相关结构  
  5 #include <arpa/inet.h>                      // 包含AF_INET相关操作的函数  
  6 #include <unistd.h>  
  7 #include<string.h>  
  8 #include<stdlib.h>  
  9 #include<fcntl.h>  
 10 #include<sys/shm.h>  
 11   
 12 #define PORT    8889  
 13 #define MYKEY   12345  
 14 #define SIZE    10240  
 15   
 16 int main()  
 17 {    
 18     int shmid;  
 19     char *shmaddr;                       //定义子进程共用的共享内存   
 20     shmid = shmget(MYKEY, SIZE, IPC_CREAT | 0600);    
 21     shmaddr= (char *) shmat(shmid, 0, 0);  
 22      
 23     if(shmid==-1)  
 24     {  
 25         printf("shmid error\n");  
 26     }  
 27     memset(shmaddr,0,SIZE);  
 28      
 29     int i=0;  
 30     char buf[100];  
 31     memset(buf,0,100);  
 32      
 33      
 34     int server_sockfd,client_sockfd;     
 35     int server_len,client_len;  
 36      
 37     struct sockaddr_in server_sockaddr,client_sockaddr;  
 38      
 39      
 40     server_sockfd = socket(AF_INET,SOCK_STREAM, 0); // 定义套接字类型  
 41      
 42     server_sockaddr.sin_family=AF_INET;  
 43     server_sockaddr.sin_port=htons(PORT);  
 44     server_sockaddr.sin_addr.s_addr=INADDR_ANY;  
 45      
 46     server_len=sizeof(server_sockaddr);  
 47      
 48     //允许重复使用本地地址和套接字绑定  
 49     int j=1;  
 50     setsockopt(server_sockfd,SOL_SOCKET,SO_REUSEADDR,&j,sizeof(j));  
 51      
 52     //绑定端口  
 53     if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,server_len)==-1)  
 54     {  
 55         perror("bind:");  
 56         exit(1);         
 57     }  
 58      
 59      
 60     if(listen(server_sockfd,5)==-1)  
 61     {  
 62         perror("listen:");  
 63         exit(1);     
 64     }  
 65     printf("Listening...\n");  
 66      
 67     client_len=sizeof(client_sockaddr);  
 68      
 69     pid_t ppid,pid;  
 70     
 71    while(1)  
 72    {    
 73     if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&client_sockaddr,&client_len))==-1)  
 74         {  
 75              perror("accept error:");  
 76              exit(1);  
 77         }  
 78      
 79     printf("%s登录服务器\n",inet_ntoa(client_sockaddr.sin_addr));  
 80      
 81     ppid=fork();  
 82      
 83     if(ppid==-1)  
 84     {  
 85         printf("fork 1 failed:");  
 86     }  
 87      
 88     if(ppid==0)                  //子进程用于接收客户端信息并发送  
 89     {  
 90         pid=fork();  
 91         if(pid==-1)  
 92         {  
 93             printf("fork 2 failed:");  
 94             exit(1);  
 95         }  
 96       
 97      int recvbytes;    
 98            
 99         if(pid==0)              //子子进程用于接收消息  
100         {    
101             while(1)  
102             {  
103                  
104                if((recvbytes=recv(client_sockfd,buf,100,0))==-1)  
105                {  
106                     perror("read client_sockfd failed:");  
107                     
108                }  
109                // printf("recvbytes=%d\n",recvbytes);  
110                 usleep(10000);  
111                printf("client send buf=%s\n",buf);  
112                  
113                 for(i=0;i<1000;i++)  
114                 {  
115                     if(*(shmaddr+100*i)==0)  
116                     {  
117                         strcpy(shmaddr+100*i,buf);    
118                         break;  
119                       
120                     }  
121                 }  
122                  
123                  
124             }  
125         }  
126          
127         if(pid>0)               //子进程用于发送消息   
128         {  
129            while(1)  
130             {  
131                 if(*(shmaddr+i*100)!=0)  
132                {  
133                    // strcpy(&buf,shmaddr+100*i);  
134                   
135                   //  buf++;  
136                     write(client_sockfd,shmaddr,SIZE);  
137                    // send(client_sockfd,buf,strlen(buf),0);  
138                     
139                  //   printf("the server is send buf=%c",buf);  
140                   //  printf("send client :%s\n",(shmaddr+i*100)) ;  
141                     i++;  
142                      
143                 }  
144             }  
145          
146         }      
147         
148     }  
149      
150      
151     if(ppid>0)              //总父进程返回等待接收消息  
152     {  
153         close(client_sockfd);  
154     }  
155          
156       
157     }  
158   
159 }

  1 #include <sys/types.h>  
  2 #include <sys/socket.h>                         // 包含套接字函数库  
  3 #include <stdio.h>  
  4 #include <netinet/in.h>                         // 包含AF_INET相关结构  
  5 #include <arpa/inet.h>                          // 包含AF_INET相关操作的函数  
  6 #include <unistd.h>  
  7 #include <string.h>  
  8 #include <time.h>  
  9   
 10 #define  PORT 8889  
 11 #define  IP_ADDR "127.0.0.1"  
 12   
 13 #define SIZE 10240  
 14   
 15 int main()  
 16 {    
 17        
 18     struct tm *timeptr;  
 19     time_t timeval;  
 20     char tm[50];  
 21     //(void)time(&timeval);  
 22     //printf("the date is %s\n",ctime(&timeval));  
 23     // printf("The time is %s\n",tm);  
 24      
 25     int sockfd;                                 // 用于保存客户套接字标识符  
 26     int len;                                    // 用于客户消息长度  
 27     struct sockaddr_in address;                 // 定义客户套接字地址  
 28   
 29     int result;  
 30      
 31   
 32     sockfd = socket(AF_INET,SOCK_STREAM, 0);    // 定义套接字类型  
 33     address.sin_family = AF_INET;               // 定义套接字地址中的域  
 34      
 35     address.sin_addr.s_addr = inet_addr(IP_ADDR);    // 定义套接字地址  
 36      
 37     address.sin_port = htons(PORT);                 // 定义套接字端口  
 38     char buf[100];                              // 定义要传送的消息  
 39     memset(buf,0,100);  
 40     char str[120];                             //存贮输入的语句  
 41      
 42     char shmaddr[SIZE];                    //接受服务器发送的全部聊天数据   
 43     int i=0;  
 44      
 45     char myname[100];  
 46     char say[10]={"[-_-]"};  
 47     char blank[10] = {"     "};  
 48     printf("欢迎来到聊天室，请输入你的姓名:\n");  
 49     scanf("%s",myname);  
 50      
 51      
 52     
 53    len = sizeof(address);  
 54    result = connect(sockfd, (struct sockaddr *) &address, len); // 请求连接  
 55   
 56    if (result == -1)    
 57     {  
 58       perror("Connect failed");  
 59       return 1;  
 60     }  
 61     printf("%s成功登录服务器:\n",myname);  
 62      
 63   
 64     pid_t pid;  
 65      
 66     pid=fork();  
 67     if(pid==-1)  
 68     {  
 69         printf("fork failed");  
 70     }  
 71      
 72     int sendbytes=0;  
 73    
 74     if(pid==0)              //子进程用于发送数据  
 75     {  
 76        while(1)  
 77         {              
 78                 scanf("%s",str);  
 79                 (void)time(&timeval);  
 80                 strcpy(tm,ctime(&timeval));  
 81   
 82                 strcpy(buf,myname);             //姓名传入buf中  
 83                 strcat(buf,blank);  
 84                 strcat(buf,tm);                 //时间传入buf中  
 85                 strcat(buf,say);                 
 86                 strcat(buf,str);                //语句传入bufz中  
 87                  
 88                  if((sendbytes=write(sockfd, buf, 100))==-1)  
 89                  {  
 90                     perror("send to server failed:");  
 91                  }  // 向服务器传送消息  
 92   
 93                  usleep(1000);  
 94                   
 95                 memset(buf,0,100);  
 96                 memset(tm,0,50);  
 97         }        
 98     }  
 99      
100     if(pid>0)               //父进程用于接受消息并读取  
101     {  
102         while(1)  
103         {  
104             read(sockfd,shmaddr,SIZE);  
105           // printf("server send shmaddr=%s\n",shmaddr);  
106              
107             if(*(shmaddr+i*100)!=0)  
108             {  
109                 printf("%s\n",(shmaddr+i*100)) ;  
110                 i++;  
111                 printf("\n");  
112             }  
113              
114             usleep(1000);  
115         }  
116      
117          
118     }  
119     close(sockfd);  
120     return 0;  
121   
122   
123 }