关于FIONREAD命令的作用[通俗易懂]

 1 
#include 
<
sys
/
types.h
>


 2 
#include 
<
sys
/
time.h
>


 3 
#include 
<
stdio.h
>


 4 
#include 
<
fcntl.h
>


 5 
#include 
<
sys
/
ioctl.h
>


 6 
#include 
<
unistd.h
>


 7 


 8 

int
 main(
int
 argc, 
char
*
 argv[])

 9 
{

10 
    
int
 debug 
=
 
0
;

11 
    
char
 buffer[
128
];

12 
    
int
 result, nread;

13 
    fd_set inputs, testfds;

14 
    
struct
 timeval timeout;

15 
    
int
 status;

16 
    
int
*
 ptr 
=
 
&
inputs;

17 
    

18 
    FD_ZERO(
&
inputs);

19 
    printf(
“
—————–before SET—–%d———–\n
“
, 
*
ptr);

20 
    FD_SET(
0
, 
&
inputs);

21 
    printf(
“
—————–after SET—–%d———–\n
“
, 
*
ptr);

22 
    

23 
    

24 
    
while
(
1
)

25 
    {

26 
        

27 
        timeout.tv_sec 
=
 
2
;

28 
        timeout.tv_usec 
=
 
500000
;

29 
        

30 
        testfds 
=
 inputs;

31 
        ptr 
=
 
&
testfds;

32 
        result 
=
 select(FD_SETSIZE, 
&
testfds, (fd_set
*
)NULL,

33 
                                        (fd_set
*
)NULL, 
/*
&timeout
*/
0
);

34 
        printf(
“
==========================================\n
“
);                                        

35 
        

36 
        sleep(
4
);

37 
        
switch
(result)

38 
        {

39 
            
case
 
0
:

40 
                printf(
“
timeout \n
“
);

41 
                debug 
=
 FD_ISSET(
0
, 
&
testfds);

42 
                printf(
“
t—————–before SET—–%d—-FD_SET–%d—–\n
“
, 
*
ptr, debug );

43 
                
break
;

44 
            
case
 
–
1
:

45 
                perror(
“
select\n
“
);

46 
                exit(
1
);

47 
            
default
:

48 
                
if
(FD_ISSET(
0
, 
&
testfds))

49 
                    {

50 
                        printf(
“
1—————–before SET—–%d———–\n
“
, 
*
ptr);

51 
                        
//
ioctl(0, FIONREAD, &nread);


52 

                        
if
(
0
 
==
 nread)

53 
                            {

54 
                                printf(
“
keyboard done \n
“
);

55 
                                exit(
0
);

56 
                            }

57 
                            printf(
“
———–result–%d———-\n
“
, result);

58 
                            nread 
=
 read(
0
, buffer, nread);

59 
                            buffer[nread] 
=
 
0
;

60 
                            printf(
“
read %d from keyboard: %s\n
“
, nread, buffer);

61 
                            

62 
                            printf(
“
1—————–after SET—–%d———–\n
“
, 
*
ptr);

63 
                    }

64 
                
break
;

65 
        }

66 
        

67 
    }

68 
    
return
 
0
;

69 
}

70 
 

  1 
/*
  For our final example, server5.c, 

  2 
    we include the sys/time.h and sys/ioctl.h headers in place of signal.h

  3 
    in our last program and declare some extra variables to deal with select.  
*/


  4 


  5 
#include 
<
sys
/
types.h
>


  6 
#include 
<
sys
/
socket.h
>


  7 
#include 
<
stdio.h
>


  8 
#include 
<
netinet
/
in
.h
>


  9 
#include 
<
sys
/
time.h
>


 10 
#include 
<
sys
/
ioctl.h
>


 11 
#include 
<
unistd.h
>


 12 


 13 

int
 main()

 14 
{

 15 
    FILE
*
 fp;

 16 
    
int
 i
=
0
;

 17 
    
int
 count 
=
 
0
;

 18 
    
int
 server_sockfd, client_sockfd;

 19 
    
int
 server_len, client_len;

 20 
    
struct
 sockaddr_in server_address;

 21 
    
struct
 sockaddr_in client_address;

 22 
    
int
 result;

 23 
    fd_set readfds, testfds;

 24 


 25 

/*
  Create and name a socket for the server.  
*/


 26 


 27 
    server_sockfd 
=
 socket(AF_INET, SOCK_STREAM, 
0
);

 28 


 29 
    server_address.sin_family 
=
 AF_INET;

 30 
    server_address.sin_addr.s_addr 
=
 htonl(INADDR_ANY);

 31 
    server_address.sin_port 
=
 htons(
9734
);

 32 
    server_len 
=
 
sizeof
(server_address);

 33 


 34 
    bind(server_sockfd, (
struct
 sockaddr 
*
)
&
server_address, server_len);

 35 


 36 

/*
  Create a connection queue and initialize readfds to handle input from server_sockfd.  
*/


 37 


 38 
    listen(server_sockfd, 
5
);

 39 
  printf(
“
—————–server_socket———-%d———-\n
“
, server_sockfd);

 40 


 41 
    FD_ZERO(
&
readfds);

 42 
    FD_SET(server_sockfd, 
&
readfds);

 43 
    

 44 
    
if
(FD_ISSET(server_sockfd, 
&
readfds))

 45 
    {

 46 
        printf(
“
fds hit!\n
“
);

 47 
    }

 48 


 49 

/*
  Now wait for clients and requests.

 50 
    Since we have passed a null pointer as the timeout parameter, no timeout will occur.

 51 
    The program will exit and report an error if select returns a value of less than 1.  
*/


 52 


 53 
    
while
(
1
) {

 54 
        
char
 ch;

 55 
        
int
 fd;

 56 
        
int
 nread;

 57 


 58 
        testfds 
=
 readfds;

 59 
        

 60 
        printf(
“
server waiting\n
“
);

 61 
        result 
=
 select(FD_SETSIZE, 
&
testfds, (fd_set 
*
)
0
, 

 62 
            (fd_set 
*
)
0
, (
struct
 timeval 
*
) 
0
);

 63 


 64 
        
if
(result 
<
 
1
) {

 65 
            perror(
“
server5
“
);

 66 
   
//
         return 0;


 67 

        }

 68 
        

 69 
        

 70 
        

 71 
        printf(
“
\\\\\\\\%d——–result—%d–\n
“
, count, result);

 72 
               

 73 


 74 

/*
  Once we know we’ve got activity,

 75 
    we find which descriptor it’s on by checking each in turn using FD_ISSET.  
*/


 76 
            count
++
;

 77 
            fp 
=
 fopen(
“
count.txt
“
, 
“
ab+
“
);

 78 
                    
for
( i
=
0
; i 
<
 FD_SETSIZE; i
++
)

 79 
                    {

 80 
                        
if
(FD_ISSET(i, 
&
testfds))

 81 
                            fprintf(fp, 
“
testfds ## count–%d——i:—-%d——-\n
“
, count, i);

 82 
                        
if
(FD_ISSET(i, 
&
readfds))

 83 
                            fprintf(fp, 
“
readfds ## count–%d——i:—-%d——-\n
“
, count, i);

 84 
                    }

 85 
                    fprintf(fp, 
“
\n
“
);

 86 
                    fclose(fp);

 87 
                    

 88 
                    

 89 
        
for
(fd 
=
 
0
; fd 
<
 FD_SETSIZE; fd
++
) {

 90 
            
//
printf(“count++++%d+++++++++++++++++++fd+++%d+++++++++++++++\n”, count, fd);


 91 

            
if
(FD_ISSET(fd,
&
testfds)) {

 92 


 93 

/*
  If the activity is on server_sockfd, it must be a request for a new connection

 94 
    and we add the associated client_sockfd to the descriptor set.  
*/


 95 
                            

 96 
                            printf(
“
*****count*******%d******************fd******%d***********\n
“
, count, fd);

 97 


 98 
                
if
(fd 
==
 server_sockfd) {

 99 
                    client_len 
=
 
sizeof
(client_address);

100 
                    client_sockfd 
=
 accept(server_sockfd, 

101 
                        (
struct
 sockaddr 
*
)
&
client_address, 
&
client_len);

102 
                    

103 
                    FD_SET(client_sockfd, 
&
readfds);

104 
                    

105 
               fp 
=
 fopen(
“
debug.txt
“
, 
“
ab+
“
);

106 
                    
for
( i
=
0
; i 
<
 FD_SETSIZE; i
++
)

107 
                    {

108 
                        
if
(FD_ISSET(i, 
&
readfds))

109 
                            fprintf(fp, 
“
serv ## count–%d——i:—-%d——-\n
“
, count, i);

110 
                    }

111 
                    fprintf(fp, 
“
———–serv—————\n
“
);

112 
                    fclose(fp);

113 
                    

114 
                    printf(
“
adding client on fd %d\n
“
, client_sockfd);

115 
                }

116 


117 

/*
  If it isn’t the server, it must be client activity.

118 
    If close is received, the client has gone away and we remove it from the descriptor set.

119 
    Otherwise, we ‘serve’ the client as in the previous examples.  
*/


120 


121 
                
else
 {

122 
                    fp 
=
 fopen(
“
debug.txt
“
, 
“
ab+
“
);

123 
                    
for
( i
=
0
; i 
<
 FD_SETSIZE; i
++
)

124 
                    {

125 
                        
if
(FD_ISSET(i, 
&
readfds))

126 
                            fprintf(fp, 
“
before ## count–%d——i:—-%d——-\n
“
, count, i);

127 
                    }

128 
                    fprintf(fp, 
“
———–before—————\n
“
);

129 
                    fclose(fp);

130 
                    

131 
                 
//
 ioctl(fd, FIONREAD, &nread);


132 

                    

133 
                    

134 


135 
                    
if
(nread 
==
 
0
) {

136 
                        close(fd);

137 
                        FD_CLR(fd, 
&
readfds);

138 
                        printf(
“
removing client on fd %d\n
“
, fd);

139 
                    }

140 


141 
                    
else
 {

142 
                        read(fd, 
&
ch, 
1
);

143 
                        sleep(
5
);

144 
                        printf(
“
serving client on fd %d\n
“
, fd);

145 
                        ch
++
;

146 
                      
//
write(fd, &ch, 1);


147 

                                                printf(
“
serving 000on fd %d\n
“
, fd);

148 
                    }

149 
                    

150 
                    fp 
=
 fopen(
“
debug.txt
“
, 
“
ab+
“
);

151 
                    
for
(i
=
0
; i 
<
 FD_SETSIZE; i
++
)

152 
                    {

153 
                        
if
(FD_ISSET(i, 
&
readfds))

154 
                            fprintf(fp, 
“
after ## count–%d——i:—-%d——-\n
“
, count, i);

155 
                    }

156 
                    fclose(fp);

157 
                }

158 
                fp 
=
 fopen(
“
debug.txt
“
, 
“
ab+
“
);

159 
                    fprintf(fp, 
“
\n\n
“
);

160 
                    fclose(fp);

161 
            }

162 
        }

163 
    }

164 
}

165