本地日志库

简单使用几个函数实现本地日志
测试OK
以链的形式装入，合并后输出，防止多进程的杂乱输出!

1. #include <stdio.h>          /*NULL*/
2. #include <stdlib.h>         /*malloc memcpy*/
3. #include <errno.h>          /*EINTR EINVAL...*/
4. #include <fcntl.h>          /*open...*/
5. #include <string.h>         /*strlen*/
6. #include <unistd.h>         /*write...*/
7. #include <sys/stat.h>       
8. #include <sys/types.h>
9. /*open parameters*/
10. #define FILE_PARMS (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
11. #define OPEN_FLAGS (O_CREAT | O_WRONLY | O_APPEND)
12. /*link list*/
13. typedef struct list{
14.     char            *data;
15.     int             len;
16.     struct list     *next;
17. }LIST;
19. static int fd = -1;             /*open's fd*/
20. static LIST *first = NULL;      /*link head*/
21. static LIST *last = NULL;       /*link tail*/
23. static int ___LocalGetLen(){
24.     int len = 0;
25.     LIST *current;
27.     current = first;
28.     while(current != NULL){
29.         len += current->len;
30.         current = current->next;
31.     }
32.     return len;
33. }
36. static LIST *___LocalInsert(int length){
37.     LIST *newlist;
38.     newlist = (LIST *)malloc(sizeof(LIST)+length);
39.     if(newlist == NULL)
40.         return NULL;
41.     newlist->data = (char *)newlist + sizeof(LIST);
42.     newlist->len = length;
43.     newlist->next = NULL;
44.     if(last == NULL)
45.         first = newlist;
46.     else
47.         last->next = newlist;
48.     last = newlist;
49.     return newlist;
50. }
53. /*
54.  * Open file
55.  * if error return -1,or return 0
56.  */
57. int LocalOpen(char *file){
58.     while( (fd = open(file,OPEN_FLAGS,FILE_PARMS)) == -1 && errno == EINTR )
59.         ;
60.     if(fd < 0){
61.         errno = EINVAL;
62.         return -1;
63.     }
64.     return 0;
65. }
66. /*
67.  * Add list to help print
68.  * if error return -1,or return 0
69.  */
70. int LocalAddString(char *data){
71.     int len;
72.     LIST *newlist;
73.     
74.     if(fd < 0){
75.         errno = EINVAL;
76.         return -1;
77.     }
78.     len = strlen(data);
79.     newlist = (LIST *)___LocalInsert(len);
80.     if(newlist == NULL)
81.         return -1;
82.     memcpy(newlist->data,data,len);
83.     return 0;
84. }
85. /*
86.  * clear all of sources
87.  * no return
88.  */
89. void LocalClear(){
90.     LIST *current;
91.     LIST *free_it;
93.     current = first;
94.     while(current != NULL){
95.         free_it = current;
96.         current = current->next;
97.         free(free_it);
98.     }
99.     first = NULL;
100.     last = NULL;
101. }
102. /*
103.  * list's data take in buf to write
104.  * if error return -1,or return 0
105.  */
106. int LocalSend(){
107.     char *buf;
108.     LIST *current;
109.     int len;
110.     ssize_t written;        /*ssize_t is int*/
112.     if(fd < 0){
113.         errno = EINVAL;
114.         return -1;
115.     }
116.     len = ___LocalGetLen();
117.     buf = (char *)malloc(len);
118.     if(buf == NULL)
119.         return -1;
120.     current = first;
121.     len = 0;
122.     while(current != NULL){
123.         memcpy(buf + len,current->data,current->len);
124.         len += current->len;
125.         current = current->next;
126.     }
127.     while( (written = write(fd,buf,len)) == -1 && errno == EINTR )
128.         ;
129.     if(written == -1 || written != len){
130.         errno = EAGAIN;
131.         free(buf);
132.         return -1;
133.     }
134.     free(buf);
135.     LocalClear();
136.     return 0;
137. }
140. /*
141.  *clear all of sources and close the fd
142.  *if failure return -1,or return 0
143.  */
144. int LocalClose(){
145.     int retval;
146.     LocalClear();
147.     while( (retval = close(fd)) == -1 && errno == EINTR )
148.         ;
149.     return retval;
150. }
152. /*
153.  * this is test program
154.  */
155. int main(){
156.     
157.     if(LocalOpen("test.txt") < 0){
158.         fprintf(stderr,"LocalOpen is fail!/n");   /*stderr haven't buffer*/
159.         return -1;
160.     }
161.     if(LocalAddString("test1:this is a log/n")){
162.         fprintf(stderr,"first LocalAddString is fail!");
163.         return -1;
164.     }
165.     if(LocalAddString("test2:this is a log/n")){
166.         fprintf(stderr,"second LocalAddString is fail!");
167.         return -1;
168.     }
169.     if(LocalSend() < 0){
170.         fprintf(stderr,"LocalSend is fail/n");
171.         return -1;
172.     }
173.     if(LocalClose() < 0){
174.         fprintf(stderr,"LocalClose is fail/n");
175.         return -1;
176.     }
177.     return 0;
178. }
179.