《UNIX网络编程 卷2》读书笔记（一）

1，获取Posix IPC的名字

#include  " unpipc.h "

char *  px_ipc_name( const   char *  name)
{
      char* dir,*dst,*slash;
      if((dst = malloc(PATH_MAX))==NULL) return NULL;//分配失败
      if((dir=getenv("PX_IPC_NAME"))==NULL)
      {//目录名
          #ifdef POSIX_IPC_PREFIX
               dir = POSIX_IPC_PREFIX;
          #else
               dir = "/tmp/";
          #endif
      }
      slash = (dir[strlen(dir)-1] == '/')?"":"/";
      snprintf(dst,PATH_MAX,"%S%S%S",dir,slash,name);//全路径名称
      return dst;
}

2，Mq_open,lsem_open,shm_open用来创建或打开一个IPC对象，第2个参数oflag指定打开IPC对象的方式。消息队列可以以只读，只写或读写任何一种模式打开，信号灯的打开不指定任何模式，共享内存区不能以只写模式打开

3，System V IPC使用key_t作为其名字，通常是先调用stat函数，再调用ftok函数得到的，函数ftok把一个已经存在的路径和一个整数标识符转换为一个key_t值,叫IPC键(IPC key).

4，内核给每个IPC对象维护一个数据结构

struct  ipc_perm
{
   uid_t uid;//owner的用户ID 
   gid_t gid;//owner的组ID 
   uid_t cuid;//creater的用户ID
   gid_t cgid;//creater的组ID
   mode_t mode;//读写模式 
   ulong_t seq;//序列号 
   key_t key;//IPC key 
} ;

   ipc_perm 结构体中的seq成员很有意思，它是作为一个计数器，每当删除一个IPC时，内核就递增这个变量，若溢出则循环回到0.

 

5，管道是最初的Unix IPC形式，其局限性在于没有名字，而且只能由有亲缘关系的进程使用。FIFO又叫有名管道，任何进程之间都能使用。两者都可以使用通常的read和write访问。

6，

#include  " unpipc.h "
void  client( int  readfd, int  writefd)
{//客户 
     size_t len;
     ssize_t n;
     char buff[MAXLINE];
     fgets(buff,MAXLINE,stdin);//读入路径名
     len = strlen(buff);
     if(buff[len-1]=='/n')//去掉结尾处的行符 
        len--;
     write(writefd,buff,len);//写入管道  
     while((n==read(readfd,buff,MAXLINE))>0)//从管道读入数据 
         write(STDOU_FILENO,buff,n);//输出 
      
}  
void  server( int  readfd, int  writefd)
{//服务器 
     int fd;
     ssize_t n;
     char buff[MAXLINE+1];

     if((n==read(readfd,buff,MAXLINE))>0)//从管道读入数据 
         buff[n]='/0';
     if((fd=open(buff,0_RDONLY))<0)
     {//给客户端返回出错信息 
         snprintf(buff+n,sizeof(buff)-n,"can't open,%s/n",strerror(errno));
         n = strlen(buff);
         write(writefd,buff,n);
     }
     else
     {
          while((n=read(fd,huff,MAXLINE))>0)
          {//给客户端返回文件内容 
              write(writefd,buff,n);
          }
          close(fd);
     }    
}

int  main( int  argc, char **  argv)
{
    int pipe1[2],pipe2[2];
    pid_t childpid;
    //创建两个管道 
    pipe(pipe1);
    pipe(pipe2);
    if((childpid=fork())==0)
    {
        close(pipe1[1]);//子进程关闭管道1的写入端 
        close(pipe2[0]);//子进程关闭管道2的读出端 
        server(pipe1[0],pipe2[1]);
        exit(0);
    }
    close(pipe1[0]);//父进程关闭管道1的读出端 
    close(pipe2[1]);//父进程关闭管道2的写入端 
    client(pipe2[0],pipe1[1]);
    waitpid(childpid,NULL,0);
    return 0;
}

上面这个例子也可以使用popen和cat来实现

#include  " unpipc.h "

int  main( int  argc, char **  argv)
{
    size_t n;
    char buff[MAXLINE],command[MAXLINE];
    FILE* fp;
    fgets(buff,MAXLINE,stdin);//读入路径名
    n = strlen(buff);
    if(buff[n-1]=='/n')n--;
    snprintf(command,sizeof(command),"cat %s",buff);//构造命令字
    fp = popen(command,"r");//创建管道并启动另一个进程
    while(fgets(buff,MAXLINE,fp)!=NULL)
        fputs(buff,stdout);
    pclose(fp);
    return 0;
}

7，FIFO是一个单向数据流，有一个路径名与之关联，从而允许没有亲缘关系的进程访问同一个FIFO，也叫有名管道(named pipe)，由函数mkfifo创建。

#include  " unpipc.h "
#define  FIFO1 "tmp/fifo.1"
#define  FIFO2 "tmp/fifo.2"

void  server( int  readfd, int  writefd)
{//服务器 
     int fd;
     ssize_t n;
     char buff[MAXLINE+1];

     if((n==read(readfd,buff,MAXLINE))>0)//从管道读入数据 
         buff[n]='/0';
     if((fd=open(buff,0_RDONLY))<0)
     {//给客户端返回出错信息 
         snprintf(buff+n,sizeof(buff)-n,"can't open,%s/n",strerror(errno));
         n = strlen(buff);
         write(writefd,buff,n);
     }
     else
     {
          while((n=read(fd,huff,MAXLINE))>0)
          {//给客户端返回文件内容 
              write(writefd,buff,n);
          }
          close(fd);
     }    
}
int  main( int  argc, char **  argv)
{
    int readfd,writefd;
    pid_t childpid;
    //创建两个有名管道 
    mkfifo(FIFO1,FILE_MODE);
    mkfifo(FIFO2,FILE_MODE);

    readfd = open(FIFO1,O_RDONLY,0);
    writefd = open(FIFO2,O_WRONLY,0);
    server(readfd,writefd);
    return 0;
}

void  client( int  readfd, int  writefd)
{//客户 
     size_t len;
     ssize_t n;
     char buff[MAXLINE];
     fgets(buff,MAXLINE,stdin);//读入路径名
     len = strlen(buff);
     if(buff[len-1]=='/n')//去掉结尾处的行符 
        len--;
     write(writefd,buff,len);//写入管道  
     while((n==read(readfd,buff,MAXLINE))>0)//从管道读入数据 
         write(STDOU_FILENO,buff,n);//输出 
      
}  

int  main( int  argc, char **  argv)
{
    int readfd,writefd;
    pid_t childpid;
    //创建两个有名管道 
    mkfifo(FIFO1,FILE_MODE);
    mkfifo(FIFO2,FILE_MODE);

    readfd = open(FIFO1,O_RDONLY,0);
    writefd = open(FIFO2,O_WRONLY,0);
    server(readfd,writefd);
    
    writefd = open(FIFO1,O_WRONLY,0);
    readfd = open(FIFO2,O_RDONLY,0);
    client(readfd,writefd);

    close(readfd);
    close(writefd);
    //删除有名管道 
    unlink(FIFO1);
    unlink(FIFO2);
    return 0;
}

8，能通过两种方式设置为非阻塞：

1）调用open时指定O_NONBLOCK标志。

2）若描述字已经打开，用fcntl来enable掉O_NONBLOCK标志，对于管道来说，必须这样，因为它没有open调用，在pipe调用中也无法指定O_NONBLOCK标志，代码如下：

int  flags;
flags  =  fcntl(fd,F_GETFL, 0 );
flags  |=  O_NONBLOCK;
fcntl(fd,F_SETFL,flags);

9，单进程服务器，多客户端

服务器代码：

int  main( int  argc, char **  argv)
{
    int readfifo,writefifo,dummyfd,fd;
    char *ptr,buff[MAXLINE],fifoname[MAXLINE];
    pid_t pid;
    ssize_t n;
    mkfifo(SERV_FIFO,FILE_MODE);
    readfifo = open(SERV_FIFO,O_RDONLY,0);//服务器的读管道 
    dummyfd = open(SERV_FIFO,O_WRONLY,0);//写管道，没使用，开启为了防止服务器管道重复打开，关闭 
    while((n=readline(readfifo,buff,MAXLINE))>0)
    {
        if(buff[n-1]=='/n')n--;
        buff[n] = '/0';
        if((ptr=strchr(buff,''))==NULL)
        {
            err_msg("请求命令错误");
            continue; 
        }
        *ptr++ = 0;
        pid = atoi(buff);//获取客户端进程号 
        snprintf(fifoname,sizeof(fifoname),"/tmp/fifo.%ld",(long)pid);
        writefifo = open(fifoname,O_WRONLY,0);//打开客户端管道的写端 
        if(fd = open(ptr,O_RDONLY,0))<0)
        {//读文件失败 
           snprintf(buff+n,sizeof(buff)-n,"can't open,%s/n",strerror(errno));
           n = strlen(ptr);
           write(writefifo,ptr,n);//往客户端管道写数据 
           close(writefifo);
        }
        else
        {
            while((n = read(fd,buff,MAXLINE))>0)
            {
                write(writefifo,buff,n);
            }
            close(fd);
            close(writefifo);
        }
    }
    return 0;
}

客户端代码:

int  main( int  argc, char **  argv)
{
    int readfifo,writefifo;
    size_t len;
    ssize_t n;
    char *ptr,buff[MAXLINE],fifoname[MAXLINE];
    pid_t pid;
    pid = getpid();//获取当前进程ID 
    snprintf(fifoname,sizeof(fifoname),"/tmp/fifo.%ld",(long)pid);
    
    mkfifo(fifoname,FILE_MODE);//创建客户端管道
    snprintf(buff,sizeof(buff),"%ld",(long)pid);
    len  = strlen(buff);
    ptr = buff+len;
    //读入文件路径名 
    fgets(ptr, MAXLINE-len,stdin);
    len = strlen(buff);
    writefifo = open(SERV_FIFO,O_WRONLY,0);//打开服务器的写管道 /
    write(writefifo,buff,len);//给服务器传送指定格式的命令字
    readfifo = open(fifoname,O_RDONLY,0);/打开客户端读管道
   
    while((n=read(readfifo,buff,MAXLINE))>0)
    {
        write(STDOUT_FILENO,buff,n);//输出 
    }
    close(readfifo);//关闭读端
    unlink(fifoname);//删除管道 
    return 0;
}

但是这个程序会导致DoS攻击,因为服务器会一直阻塞在对客户端FIFO的open调用中，若客户端不打开此FIFO来读，则服务器会一直阻塞，因此客户很容易通过阻止发送封包来使得服务器垮掉，解决办法有很多，可以一个客户一个进程，或一个客户一个线程，或使用进程池，或线程池。

10,UNIX默认的I/O模型是字节流模型,也就是不存在记录边界,一般有3种技巧来改造：

1）带内特殊终止序列：很多使用换行符来分隔每个消息，写入进程给每个消息加入一个换行符，读出进程每次读出一行，但缺点是分隔符要进行转义处理。如:FTP,SMTP等就使用一个回车后跟一个换行符来分隔记录。

2）显示长度：记录前加入其长度。

3）一次连接一个记录，通过关闭与对方的连接来指示一个记录结束，例如HTTP1.0

#include  " unpipc.h "

#define  MAXMESGDATA (PIPE_BUF-2*sizeof(long))
#define  MESGHDRSIZE (sizeof(struct mymesg)-MAXMESGDATA)

struct  mymesg
{
   long mesg_len;//消息长度 
   long mesg_type;//消息类型 
   long mesg_data[MAXMESGDATA];//数据域 
} ;

size_t mesg_send( int  fd, struct  mymesg *  mptr)
{
   return(write(fd,mptr,MESGHDRSIZE+mptr->mesg_len));
}

ssize_t mesg_recv( int  fd, struct  mymesg *  mptr)
{
   size_t len;
   ssize_t n;
   if((n = read(fd,mptr,MESGHDRSIZE))==0)
   {
       return 0;
   }
   else if(n!= MESGHDRSIZE)
      err_quit("头部错误");
   if((len = mptr->mesg_len)>0)
   {
      if((n=read(fd,mptr->mesg_data,len))!=len)
         err_quit("数据错误"); 
   } 
   return len;
   
}
void  client( int  readfd, int  writefd)
{//客户 
     size_t len;
     ssize_t n;
     struct mymesg mesg;
     
     char buff[MAXLINE];
     fgets(mesg.mesg_data,MAXMESGDATA,stdin);//读入路径名
     len = strlen(mesg.mesg_data);
     if(mesg.mesg_data[len-1]=='/n')//去掉结尾处的行符 
        len--;
     mesg.mesg_len = len;
     mesg.mesg_type = 1;
     mesg_send(writefd,&mesg);
     while((n==mesg_recv(readfd,&mesg))>0)//从管道读入数据 
         write(STDOU_FILENO,mesg.mesg_data,n);//输出 
      
}  
void  server( int  readfd, int  writefd)
{//服务器 
     int fd;
     ssize_t n;
     char buff[MAXLINE+1];
     FIFL *fp;
     struct mymesg mesg;
     mesg.mesg_type = 1;
     

     if((n==mesg_recv(readfd,&mesg))>0)//从管道读入数据 
         mesg.mesg_data[n]='/0';
     if((fd=fopen(mesg.mesg_data,"r"))==NULL)
     {//给客户端返回出错信息 
         snprintf( mesg.mesg_data+n,sizeof( mesg.mesg_data)-n,"can't open,%s/n",strerror(errno));
          mesg.mesg_len = strlen( mesg.mesg_data);
         mesg_send(writefd, &mesg);
     }
     else
     {
          while(fgets( mesg.mesg_data,MAXMESGDATA,fp))!=NULL)
          {//给客户端返回文件内容 
              mesg.mesg_len = strlen(mesg.mesg_data);
              mesg_send(writefd,&mesg);
          }
          fclose(fp);
     }  
     mesg.mesg_len = 0 ;
     mesg_send(writefd,&mesg);  
}