open函数返回值

hm2462964492

1. #include <stdio.h>
   
2. #include <malloc.h>
   
3. #include <assert.h>
   
4. #include <stdarg.h>
   
5. #include <stdint.h>
   
6. #include <time.h>
   
7. #include <limits.h>
   
8. #include <string.h>
   
9. #include <unistd.h>
   
10. #include <stddef.h>
    
11. #include <errno.h>
    
12. #include <stdlib.h>
    
13. #include <sys/stat.h>
    
14. #include <sys/types.h>
    
15. #include <fcntl.h>
    
16. 
    
17. #define false 0
    
18. #define true 1
    
19. 
    
20. 
    
21. #define TCFILEMODE     00644             // permission of a creating file
    
22. #define TCIOBUFSIZ     16384             // size of an I/O buffer
    
23. #define TCXSTRUNIT     12                // allocation unit size of an extensible string
    
24. 
    
25. #define MYMALLOC       malloc
    
26. #define MYCALLOC       calloc
    
27. #define MYREALLOC      realloc
    
28. #define MYFREE         free
    
29. 
    
30. /* Alias of `tcxstrsize'. */
    
31. #define TCXSTRSIZE(TC_xstr) \
    
32.   ((TC_xstr)->size)
    
33. 
    
34. /* Alias of `tcrealloc'. */
    
35. #if defined(_MYFASTEST)
    
36. #define TCREALLOC(TC_res, TC_ptr, TC_size) \
    
37.   do { \
    
38.     (TC_res) = MYREALLOC((TC_ptr), (TC_size)); \
    
39.   } while(false)
    
40. #else
    
41. #define TCREALLOC(TC_res, TC_ptr, TC_size) \
    
42.   do { \
    
43.     if(!((TC_res) = MYREALLOC((TC_ptr), (TC_size)))) ; \
    
44.   } while(false)
    
45. #endif
    
46. 
    
47. /* Alias of `tcmalloc'. */
    
48. #if defined(_MYFASTEST)
    
49. #define TCMALLOC(TC_res, TC_size) \
    
50.   do { \
    
51.     (TC_res) = MYMALLOC(TC_size); \
    
52.   } while(false)
    
53. #else
    
54. #define TCMALLOC(TC_res, TC_size) \
    
55.   do { \
    
56.     if(!((TC_res) = MYMALLOC(TC_size))); \
    
57.   } while(false)
    
58. #endif
    
59. 
    
60. /* Alias of `tcfree'. */
    
61. #define TCFREE(TC_ptr) \
    
62.   do { \
    
63.     MYFREE(TC_ptr); \
    
64.   } while(false)
    
65. 
    
66. 
    
67. /* Convert an extensible string object into a usual allocated region. */
    
68. typedef struct {                         /* type of structure for an extensible string object */
    
69.   char *ptr;                             /* pointer to the region */
    
70.   int size;                              /* size of the region */
    
71.   int asize;                             /* size of the allocated region */
    
72. } TCXSTR;
    
73. 
    
74. 
    
75. /* Alias of `tcxstrcat'. */
    
76. #define TCXSTRCAT(TC_xstr, TC_ptr, TC_size) \
    
77.   do { \
    
78.     int TC_mysize = (TC_size); \
    
79.     int TC_nsize = (TC_xstr)->size + TC_mysize + 1; \
    
80.     if((TC_xstr)->asize < TC_nsize){ \
    
81.       while((TC_xstr)->asize < TC_nsize){ \
    
82.         (TC_xstr)->asize *= 2; \
    
83.         if((TC_xstr)->asize < TC_nsize) (TC_xstr)->asize = TC_nsize; \
    
84.       } \
    
85.       TCREALLOC((TC_xstr)->ptr, (TC_xstr)->ptr, (TC_xstr)->asize); \
    
86.     } \
    
87.     memcpy((TC_xstr)->ptr + (TC_xstr)->size, (TC_ptr), TC_mysize); \
    
88.     (TC_xstr)->size += TC_mysize; \
    
89.     (TC_xstr)->ptr[(TC_xstr)->size] = '\0'; \
    
90.   } while(false)
    
91. 
    
92. 
    
93. void *tcxstrtomalloc(TCXSTR *xstr){
    
94.   assert(xstr);
    
95.   char *ptr;
    
96.   ptr = xstr->ptr;
    
97.   TCFREE(xstr);
    
98.   return ptr;
    
99. }
    
100. 
     
101. 
     
102. /* Create an extensible string object. */
     
103. TCXSTR *tcxstrnew(void){
     
104.   TCXSTR *xstr;
     
105.   xstr = malloc(sizeof(*xstr));
     
106.   xstr->ptr = malloc(TCXSTRUNIT);
     
107.   xstr->size = 0;
     
108.   xstr->asize = TCXSTRUNIT;
     
109.   xstr->ptr[0] = '\0';
     
110.   return xstr;
     
111. }
     
112. 
     
113. /* Get the larger value of two integers. */
     
114. long tclmax(long a, long b){
     
115.   return (a > b) ? a : b;
     
116. }
     
117. 
     
118. 
     
119. /* Get the lesser value of two integers. */
     
120. long tclmin(long a, long b){
     
121.   return (a < b) ? a : b;
     
122. }
     
123. 
     
124. /* Read whole data of a file. */
     
125. void *tcreadfile(const char *path, int limit, int *sp){
     
126.   int fd = path ? open(path, O_RDONLY, TCFILEMODE) : 0;
     
127.   if(fd == -1) return NULL;
     
128.   if(fd == 0){
     
129.     TCXSTR *xstr = tcxstrnew();
     
130.     char buf[TCIOBUFSIZ];
     
131.     limit = limit > 0 ? limit : INT_MAX;
     
132.     int rsiz;
     
133.     while((rsiz = read(fd, buf, tclmin(TCIOBUFSIZ, limit))) > 0){
     
134.       TCXSTRCAT(xstr, buf, rsiz);
     
135.       limit -= rsiz;
     
136.     }
     
137.     if(sp) *sp = TCXSTRSIZE(xstr);
     
138.     return tcxstrtomalloc(xstr);
     
139.   }
     
140.   struct stat sbuf;
     
141.   if(fstat(fd, &sbuf) == -1 || !S_ISREG(sbuf.st_mode)){
     
142.     close(fd);
     
143.     return NULL;
     
144.   }
     
145.   limit = limit > 0 ? tclmin((int)sbuf.st_size, limit) : sbuf.st_size;
     
146.   char *buf;
     
147.   TCMALLOC(buf, sbuf.st_size + 1);
     
148.   char *wp = buf;
     
149.   int rsiz;
     
150.   while((rsiz = read(fd, wp, limit - (wp - buf))) > 0){
     
151.     wp += rsiz;
     
152.   }
     
153.   *wp = '\0';
     
154.   close(fd);
     
155.   if(sp) *sp = wp - buf;
     
156.   return buf;
     
157. }
     
158. 
     
159. 
     
160. int main()
     
161. {
     
162.         char *numstr = tcreadfile("/ttserver/ttserver.pid", -1, NULL);
     
163. }

复制代码

哪位大侠解释一下open函数返回0是什么意思啊，为什么等于0的时候要用结构体存取结构体中的内容