time怎么会篡改内存呢？！

pseudoam

我写的一个简单的时钟管理的程序，使用SIGALRM信号，其中用到了time函数。刚开始运行总是出新segment error，我gdb调试之后发现，原来是在执行完time函数之后，我之前malloc出来的一块内存被篡改了，所以报了段错误。我把time函数注释掉之后程序就正常了。所以我非常不解，为什么这个time会篡改内存呢？！还是我的程序写的有问题？！

代码贴在下面，希望帮小弟看看。小弟是个菜鸟，希望大侠指教。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <signal.h>
   
5. 
   
6. typedef void (* tm_hdlr)(void* data);
   
7. 
   
8. struct listnode {
   
9.     unsigned int time;
   
10.     tm_hdlr handler;
    
11.     void* data;
    
12.     struct listnode* next;
    
13. };
    
14. 
    
15. typedef struct listnode* list;
    
16. 
    
17. struct listnode* mknode(list* ls, unsigned int time, tm_hdlr handler, void* data)
    
18. {
    
19.     if (ls == NULL)
    
20.         return NULL;
    
21.    
    
22.     struct listnode* tmp = (struct listnode*) malloc(sizeof(struct listnode));
    
23.     if (tmp == NULL)
    
24.         return NULL;
    
25.     tmp->time = time;
    
26.     tmp->handler = handler;
    
27.     tmp->data = data;
    
28.     tmp->next = NULL;
    
29. 
    
30.     if (*ls == NULL)
    
31.     {
    
32.         *ls = tmp;
    
33.         return tmp;
    
34.     }
    
35.     //list cur = *ls, prev;
    
36.     struct listnode* head = *ls;
    
37.     printf("head time [%d]\n", head->time);
    
38.     struct listnode* cur = head;
    
39.     struct listnode* prev = head;
    
40.     for (; cur != NULL && cur->time < time;)
    
41.     {
    
42.         prev = cur;
    
43.         cur = cur->next;
    
44.     }
    
45. 
    
46.     if (cur == prev)
    
47.     {//insert head
    
48.         tmp->next = cur;
    
49.         *ls = tmp;
    
50.     } else {
    
51.         tmp->next = prev->next;
    
52.         prev->next = tmp;
    
53.     }
    
54. 
    
55.     return tmp;
    
56. }
    
57. 
    
58. struct listnode* pollnode(list* ls)
    
59. {
    
60.     if (ls == NULL || *ls == NULL)
    
61.         return NULL;
    
62.     struct listnode* tmp = *ls;
    
63.     *ls = (*ls)->next;
    
64.     return tmp;
    
65. }
    
66. 
    
67. void rmnode(struct listnode* node)
    
68. {
    
69.     free(node);
    
70. }
    
71. 
    
72. void rmlist(list* ls)
    
73. {
    
74.     list head = *ls;
    
75.     struct listnode* tmp = NULL;
    
76.     while (NULL != head)
    
77.     {
    
78.         tmp = head;
    
79.         head = head->next;
    
80.         rmnode(tmp);
    
81.     }
    
82.     *ls = NULL;
    
83. }
    
84. 
    
85. void testlist()
    
86. {
    
87.     list ls = NULL;
    
88.     mknode(&ls, 10, NULL, NULL);
    
89.     mknode(&ls, 3, NULL, NULL);
    
90.     mknode(&ls, 8, NULL, NULL);
    
91.     mknode(&ls, 5, NULL, NULL);
    
92.     mknode(&ls, 1, NULL, NULL);
    
93.     struct listnode* node = pollnode(&ls);
    
94.     rmnode(node);
    
95.     node = pollnode(&ls);
    
96.     rmnode(node);
    
97.     node = pollnode(&ls);
    
98.     rmnode(node);
    
99.     rmlist(&ls);
    
100. }
     
101. 
     
102. struct tm_mgr {
     
103.     list tm_list;
     
104.     struct sigaction tm_osa;
     
105. };
     
106. 
     
107. 
     
108. void th0(void* data)
     
109. {
     
110.     printf("th0");
     
111. }
     
112. 
     
113. static struct tm_mgr* g_tm = NULL;
     
114. 
     
115. void sig_alrm(int signum)
     
116. {
     
117.     if (g_tm == NULL)
     
118.         perror("G_TM == NULL");
     
119.     printf("sig_alrm\n");
     
120.     if (g_tm->tm_list == NULL)
     
121.     {
     
122.         printf("IT'S SHOULD NOT BE THIS, THERE IS SOMETHING WRONG!\n");
     
123.         return ;
     
124.     }
     
125.     struct listnode* tmp = pollnode(&(g_tm->tm_list));
     
126.     list ls = g_tm->tm_list;
     
127.     if (ls == NULL)
     
128.     {
     
129.         printf("NO NEXT TIME!\n");
     
130.         return ;
     
131.     }
     
132.     //set next one.
     
133.     //int now = time();
     
134.     int now = 0;
     
135.     int firetime = ls->time - now;
     
136.     alarm(firetime);
     
137. }
     
138. 
     
139. struct tm_mgr* init_tm()
     
140. {
     
141.     struct tm_mgr* tm = (struct tm_mgr*) malloc(sizeof(struct tm_mgr));
     
142.     printf("struct tm_mgr size [%d]\n", sizeof(struct tm_mgr));
     
143.     tm->tm_list = NULL;
     
144.     struct sigaction sa;
     
145.     sa.sa_flags = 0;
     
146.     sigemptyset(&sa.sa_mask);
     
147.     sa.sa_handler = sig_alrm;
     
148.     if (-1 == sigaction(SIGALRM, &sa, &(tm->tm_osa)))
     
149.         return NULL;
     
150.     g_tm = tm;
     
151.     return tm;
     
152.     //static struct tm_mgr tm;
     
153.     //tm.tm_list = NULL;
     
154.     //struct sigaction sa;
     
155.     //sa.sa_flags = 0;
     
156.     //sigemptyset(&sa.sa_mask);
     
157.     //sa.sa_handler = sig_alrm;
     
158.     //if (-1 == sigaction(SIGALRM, &sa, &(tm.tm_osa)))
     
159.         //return NULL;
     
160.     //g_tm = &tm;
     
161.     //return &tm;
     
162. }
     
163. 
     
164. void reg_timer(struct tm_mgr* tm, unsigned int seconds, tm_hdlr handler, void* data)
     
165. {
     
166.     if (tm == NULL)
     
167.         return ;
     
168. 
     
169.     //PROB!!!!
     
170.     //int now = time();
     
171.     int now = 0;
     
172.     int fire = now + seconds;
     
173.     struct listnode* node = mknode(&(tm->tm_list), fire, handler, data);
     
174.     list ls = tm->tm_list;
     
175.     if (node == ls)
     
176.     {//insert at first.        
     
177.         alarm(seconds);
     
178.     }
     
179. }
     
180. 
     
181. //void begin_timer(struct tm_mgr* tm)
     
182. //{
     
183.    
     
184. //}
     
185. 
     
186. void term_tm(struct tm_mgr* tm)
     
187. {
     
188.     if (-1 == sigaction(SIGALRM, &(tm->tm_osa), NULL))
     
189.         return ;
     
190.     if (tm != NULL)
     
191.     {
     
192.         rmlist(&(tm->tm_list));
     
193.         free(tm);
     
194.     }
     
195.     g_tm = NULL;
     
196. }
     
197. 
     
198. void sig_int(int signum)
     
199. {
     
200.     reg_timer(g_tm, 1, th0, (void*)0);
     
201. }
     
202. 
     
203. int main()
     
204. {
     
205.     //testlist();
     
206. 
     
207.     if (SIG_ERR == signal(SIGINT, sig_int))
     
208.         perror("SIGNAL");
     
209. 
     
210.     struct tm_mgr *tm = init_tm();
     
211.     reg_timer(tm, 1, th0, (void*)0);
     
212.     reg_timer(tm, 2, th0, (void*)1);
     
213.     reg_timer(tm, 3, th0, (void*)2);
     
214. 
     
215.     //begin_timer(tm);
     
216. 
     
217.     for (;;)
     
218.         pause();
     
219. 
     
220.     term_tm(tm);
     
221.     return 0;
     
222. }
     

复制代码

pseudoam

我刚才发现了一个我编程上的错误，我需要获取当前时间。原型是：
time_t time(time_t *t);//time.h
我没有加参数NULL，换成time(NULL)之后程序正常，但是还是不知道为什么time()这个普通的函数会修改内存呢？！

chnliyong

只能说这是你操作不当引起的，标准用法本来就需要加参数，你不按标准来使用出现的错误根据编译器的不同可能会有所不同，函数调用跳转前参数一般都是先push进栈的，在执行时直接pop栈得到参数，你这个由于没有参数就没有参数入栈，但time函数执行时从栈里获取参数，修改了栈内容，同时获取的是某个不确定的值，操作以这个值为内存地址的内存会导致段错误是很正常的

pseudoam

chnliyong 发表于 2012-04-21 17:10
只能说这是你操作不当引起的，标准用法本来就需要加参数，你不按标准来使用出现的错误根据编译器的不同可能 ...

恩，我觉得你说的有道理。不过被篡改的内存是malloc出来的，在堆上呀。

pseudoam

回复 3# chnliyong

噢，的确是你说的那样，把tm_mgr*当作了time_t*然后向指向的内存写时间，因为指针指向的是堆内存，所以写到了堆上。
谢谢！
   

ulovko

向大家学习，看看应该怎么解决！