Chinaunix首页 | 论坛 | 博客

popsicle2008

首页　| 　博文目录　| 　关于我

popsicle2008

  • 博客访问： 211762
  • 博文数量： 58
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 11
  • 用 户 组： 普通用户
  • 注册时间： 2014-09-02 01:08
文章分类

全部博文（58）

文章存档

2020年（1）

2018年（2）

2017年（1）

2016年（7）

2015年（31）

2014年（16）

我的朋友
最近访客
推荐博文
相关博文
LINUX C 的 socket 编程 -----(1)

分类： C/C++

2015-08-09 18:01:03

原文地址：LINUX C 的 socket 编程 -----(1) 作者：glinuxi

一：引子
      在网络五层中：数据链路层-----------------------------------MAC地址
                               网际层----------------------------------------IP地址
                               传输层----------------------------------------IP地址：端口号
二：端口
     有了网络地址，就可以唯一标识网络上的每台计算机，但是在一台计算机上面可以同时运行多个程序，而他们可能同时要访问网络，对于一台计算机上的多个应用程 序，TCP 和 UDP协议采用了16位的端口号来标识他们。一台主机上的不同进程可以绑定到不同的端口上，这些进程都可以访问网络而互不干扰。
  0---------1023           知名端口     由权威机构规定其用途
  1024-----65535        自由端
三：相关数据结构
1、套接字地址结构 struct sockaddr{  unsigned short sa_family; char sa_data[14];};
     sa_family : 表示套接字的协议类型，对应于TCP/IP协议该值为 AF_INET;
     sa_data    : 用于存储具体的协议地址，他等价于一个数据结构：sockadd_in
2、TCP/IP地址协议族格式：struct sockaddr_in { unsigned short sin_family; unsigned short int  sin_port; struct
      in_addr sin_addr ; unsigned char  sin_zero[8]; };
      sin_family: 表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能为AF_INET。
      sin_port   : 表示端口号
      sin_addr  : 用于存储32位的IP地址
      sin_zero  : 该数组作为填充字段，一般赋值为0
3、struct in_addr {unsigned long s_addr};
四、调用函数
I ：创建套接字  int socket (int domain, int type , int protocol)
      --------domain用于指定创建套接字所使用的协议族。
          AF_UNIX # 创建只在本机进行通信的套接字；
          AF_INET # 使用IPv4TCP/IP协议；
          AF_INET6 # 使用IPv6TCP/IP协议
     ---------type用于指定套接字的类型。
          SOCK_STREAM # 创建TCP流套接字；
          SOCK_DGRAM # 创建DUP套接字；
          SOCK_RAW      # 创建原始套接字；
    ----------protocol通常设定为0，表示通过参数domain指定的协议族和参数type指定的套接字类型来确定使用的协议。
II：建立连接 int connect (int sockfd, const struct sockaddr * serv_addr,socklen_t addrlen)
    ---------sockfd是由一个函数socket创建的套接字
    --------- addrlen是serv_addr的长度
III：绑定套接字 int bind (int sockfd , struct sockaddr * my_addr, socklen_t addrlen)
     --------对于只有一个IP地址的计算机表示本机的IP地址，对于有多个IP地址则表示本服务程序将处理来自所有网
                络接口上相应端口的连接请求。
IV：在套接字上创建监听 int listen(int s, int len)
     ---------通过函数socket()创建的字是主动套接字，这种套接字可以用来主动请求链接到某个服务器，但是作为服
                 务器端的程序，通常在某个端口上监听等待来自客户端的连接请求。
     ---------通过listen将该套接字转换为监听套接字，等待来自于客户端的连接请求。一般多个客户可以连接到一个服务器上，服务器向这些客户端提供某种服务，服务器端设置一个连接队列，记录已经建立的连接，参数len指定了该连接队列的最大长度。
IIV：接受连接 int accept(int s, struct sockaddr *addr , socklen_t *addrlen)
     ---------s 是由函数socket创建，经过函数bind绑定的到本地某一个端口上，然后通过函数listen转换而来的监听套
                 接字
     ---------addr 用来保存发起连接请求的主机的地址和端口
     ---------addrlen 是参数addr所指向的结构体的大小
IIIV：ssize_t   send(int s, const void *msg, size_t len , int flags)
     -------------s是已经建立好的套接字描述符
     -------------flags是控制选项
                     MSG_OOB               # 在指定的套接字上发送带外数据，该类型的套接字必须支持带外数据
                     MSG_DONTROUTE  #  通过最直接的路径发送数据，而忽略下层协议的路由设置
         ssize_t   recv(int socked,const void *msg, size_t len , int flags)
     -------------flags是控制选项
                     MSG_OOB               # 请求接收带外数据
                     MSG_PEEK               # 查看数据而不读出
                     MSG_WAITALL        # 只在接收缓冲区满时才返回
四：C/S 结构模型图
五：程序实例

server.c

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<sys/types.h>
  4. #include<sys/socket.h>
  5. #include<string.h>
  6. #include<unistd.h>
  7. #include<netinet/in.h>
  8. #include<arpa/inet.h>

  10. #define USERNAME 0
  11. #define USERPASS 1
  12. #define PORT_SERV 4055
  13. #define LISTENL 12
  14. #define BUFSIZE 1024
  15. struct userinfo{
  16. char username[32];
  17. char userpass[32];
  18. };
  19. typedef struct userinfo userinfo_c;
  20. userinfo_c users[]={{"linux","unix"},{"787","007"},{"gyeve","gaoyi"}};
  21. int send_data(int con,char *buf)
  22. {
  23.     int ret;
  24.     ret=send(con,buf,sizeof(buf),0);
  25.     if(ret<=0){
  26.         printf("send is wrong\n");
  27.     return ret;
  28.     }
  29.     return ret;
  30. }
  31. int find_name(char *name)
  32. {
  33.     int index=0;
  34.     for(index=0;index<3;index++)
  35.     {
  36.     printf("name = %s username = %s\n",name,users[index].username);
  37.         if(strcmp(users[index].username,name)==0)
  38.             return index;
  39.     }
  40.     return -1;
  41. }
  42. int main()
  43. {
  44.     int socket_id,optval,user_id,accpt_len;
  45.     struct sockaddr_in server_ad,client_ad;
  46.     int acc_res, ret,flag=USERNAME;
  47.     pid_t pid;
  48.     char buf[BUFSIZE];

  50.     socket_id = socket(AF_INET,SOCK_STREAM,0);
  51.     if(socket_id <=0) {
  52.      perror("socket");
  53.      exit(1);
  54.     }
  55.     optval=1;
  56.     if(setsockopt(socket_id,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(int))<0){/*设置窗口重新绑定*/
  57.     perror("setsockopt");
  58.     exit(2);
  59.     }
  60.     memset(&server_ad,0,sizeof(struct sockaddr_in));
  61.     server_ad.sin_family = AF_INET; /*ipv4 of the tcp/ip protocol */
  62.     server_ad.sin_port = htons(PORT_SERV);
  63.     server_ad.sin_addr.s_addr = htonl(INADDR_ANY);/* the localhost ip address */

  65.     if(bind(socket_id,(struct sockaddr *)&server_ad,sizeof(struct sockaddr_in))<0)
  66.     {
  67.     perror("bind");
  68.     exit(3);
  69.     }
  70.     if(listen(socket_id,LISTENL)<0)
  71.     {
  72.     perror("listen");
  73.     exit(4);
  74.     }
  75.     accpt_len= sizeof(struct sockaddr_in);
  76.     while(1)
  77.     {
  78.     acc_res = accept(socket_id,(struct sockaddr *)&client_ad,&accpt_len);
  79.     if(acc_res <0)
  80.     {
  81.     perror("1accept");
  82.     exit(5);
  83.     }
  84.     printf("accept a new client ,the ip = %s\n",inet_ntoa(client_ad.sin_addr));
  85.     if((pid=fork())==0){
  86.         while(1){
  87.         memset(buf,0,BUFSIZE);
  88.         if((ret=recv(acc_res,buf,BUFSIZE,0))<0){
  89.         perror("recv");
  90.         exit(7);
  91.         }
  92.         buf[ret]=0;
  93.         printf("buf = %s\n",buf);
  94.         if(flag==USERNAME){
  95.             user_id=find_name(buf);
  96.             switch(user_id)
  97.             {
  98.                 case -1:send_data(acc_res,"n\n");
  99.                 break;
  100.                 default:send_data(acc_res,"y\n");
  101.                 flag = USERPASS;
  102.             }
  103.         }
  104.         else if( flag==USERPASS ){
  105.             if(strcmp(users[user_id].userpass,buf)==0)
  106.             {
  107.                 send_data(acc_res,"y\n");
  108.                 send_data(acc_res,"welcome login my cp server\n");
  109.                 printf("%s login\n",users[user_id].username);
  110.                 break;
  111.             }else
  112.                 send_data(acc_res,"n\n");
  113.         }
  114.         }
  115.         
  116.         close(socket_id);
  117.         close(acc_res);
  118.         exit(0);
  119.         }
  120.     else
  121.         close(acc_res);
  122.     }
  123.     return 0;
  124. }

client.c

  1. #include<stdio.h>
  2. #include<arpa/inet.h>
  3. #include<netinet/in.h>
  4. #include<sys/types.h>
  5. #include<sys/socket.h>
  6. #include<stdlib.h>
  7. #include<string.h>
  8. #define LEN 1024
  9. #define VALID 1
  10. #define INVALID 0
  11. int my_recv(int con, char buf[], int len)
  12. {
  13.     int ll;
  14.     ll = recv(con,buf,sizeof(buf),0);
  15.     if(ll<0){
  16.         perror("recv");
  17.         exit(1);
  18.     }
  19.     return ll;
  20. }
  21. void input_mess(int con, const char *string)
  22. {
  23.     char input_buf[32];
  24.     char recv_buf[LEN];
  25.     int flag_userinfo;
  26.     do{
  27.         printf("%s:",string);

  29.         gets(input_buf);
  30.         input_buf[strlen(input_buf)]=0;
  31.         printf("%s:",input_buf);
  32.         if(send(con,input_buf,strlen(input_buf),0)<0)
  33.         {
  34.             perror("send");
  35.             exit(1);
  36.         }
  37.         if(my_recv(con,recv_buf,sizeof(recv_buf))<0)
  38.         {
  39.             perror("my_recv");
  40.             exit(1);
  41.         }
  42.         printf("recv = %s\n",recv_buf);
  43.         if(recv_buf[0]=='y')
  44.             flag_userinfo = VALID;
  45.         else
  46.             flag_userinfo = INVALID;
  47.         memset(recv_buf,0,sizeof(recv_buf));
  48.     }while(flag_userinfo == INVALID);
  49. }
  50. int main(int argc, char *argv[])
  51. {
  52.     int i,ret;
  53.     int conn_fd,socketd;
  54.     char recvbuf[LEN]={0};
  55.     struct sockaddr_in serv_addr;

  57.     if(argc!=5)
  58.     {
  59.         printf("the argc is not equals 5\n");
  60.         return -1;
  61.     }
  62.     memset(recvbuf,0,LEN);
  63.     memset(&serv_addr,0,sizeof(struct sockaddr_in));
  64.     serv_addr.sin_family=AF_INET;
  65.     for(i=0;i<argc;i++)
  66.     {
  67.         if(strcmp(argv[i],"-a")==0)
  68.         {
  69.             i++;
  70.             if(inet_aton(argv[i],&serv_addr.sin_addr)==0){
  71.                 printf("invaild server ip address \n");
  72.                 exit(1);
  73.             }/*如果该for中两个条件的判定是通过两个if链接的，那么要使用continue*/
  74.         }
  75.         else if(strcmp(argv[i],"-p")==0)
  76.         {
  77.             i++;
  78.             int port = atoi(argv[i]);
  79.             if(port<0||port>=65536) {
  80.                 printf("the port is overwiding\n");
  81.                 break;
  82.             }else{
  83.             serv_addr.sin_port = htons(port);
  84.             }
  85.         }
  86.     }
  87.     if(serv_addr.sin_addr.s_addr == 0||serv_addr.sin_port == 0)
  88.     {
  89.         printf("usage [-a] [address] [-p] [port]\n");
  90.         exit(1);
  91.     }
  92.     socketd = socket(AF_INET,SOCK_STREAM,0);
  93.     conn_fd = connect(socketd,(struct sockaddr*)&serv_addr,sizeof(struct sockaddr));
  94.     if(conn_fd<0)
  95.     {
  96.         perror("connect");
  97.         exit(1);
  98.     }
  99.     input_mess(socketd,"username");
  100.     input_mess(socketd,"userpass");
  101.     if((ret=my_recv(socketd,recvbuf,LEN))<0)
  102.     {
  103.         printf("data is too long");
  104.         exit(1);
  105.     }
  106. //    recvbuf[ret]=0;
  107.     printf("%s\n",recvbuf);
  108.     

  110.     return 0;
  111. }
六：编写程序遇到的问题

accept: Bad file descriptor---------------将accept创建的套接字在不合适的场合关了
connect: connected refused-------------connect的参数s有问题

            
阅读(1523) | 评论(0) | 转发(0) |
0

上一篇：探究linux内核,超详细解析子系统

下一篇：Linux网络编程：原始套接字的魔力【上】

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6