请教: 怎样判断一个变量是只读的(const)?

donotblock

回复 23# hello|world


    错误不是用来屏蔽的。 如果他误传了个常量给你，你不报错，仅仅是什么都不做，以后出现问题他一定会骂你的。

雨夜流星

回复  hello|world


    错误不是用来屏蔽的。 如果他误传了个常量给你，你不报错，仅仅是什么都不做， ...
donotblock 发表于 2011-02-16 09:13

    接口应该明确写出输入输出参数的类型和范围，如果你都告诉他要使用char *了，他还非要用const char *，到时候出了问题，他敢骂你？

donotblock

接口应该明确写出输入输出参数的类型和范围，如果你都告诉他要使用char *了，他还非要用const ch ...
雨夜流星 发表于 2011-02-16 10:05

    我是说该让他出错或崩溃而不让他出错会被骂。。。你完全理解反了我的意思

rong_bo

可能楼主需要的是这个
IsBadWritePtr

xiaobird1982

用objdump看这个变量符号的存在位置，如果在.rodata则是只读的。
davelv 发表于 2011-02-15 10:38

    看生成可执行文件中这个变量在什么区 如果是RO区 说明是只读的 推荐看一下ELF文件格式

xiaobird1982

实在想知道的话 就比较地址范围吧

在链接文件中存有RO区地址的范围, 在程序中比较即可


if(&var > 0x08004000 && &var < 0x08006000)

selfrun

需求是合理的吗？
设计是合理的吗？
是哪里出的错误？
哪里出的错误就在哪里解决。

hello|world

回复 34# rong_bo

必须感谢下这个回复,不管以后是否能用上,确实也是一种办法~

1. #include   <setjmp.h>
   
2. #include   <signal.h>
   
3. #include   <stdlib.h>
   
4. #include   <stdio.h>
   
5. 
   
6. /*
   
7.   ***************************
   
8.   *   Global   Variables   
   
9.   ***************************
   
10. */
    
11. static   volatile   sig_atomic_t   segv_flag;
    
12. static   jmp_buf   jmp_env;
    
13. 
    
14. /*
    
15.   ********************************************
    
16.   *   Pre:   none   
    
17.   *   Post:   restore   the   original   process   state   
    
18.   *       and   return   1   to   setjmp
    
19.   ********************************************
    
20. */
    
21. static   void   segv_handler(   int   dummy   )
    
22. {
    
23. segv_flag   =   1;
    
24. longjmp(   jmp_env   ,   1);
    
25. }
    
26. 
    
27. /*
    
28.   ********************************************
    
29.   *   Pre:   A   pointer   and   it 's   length
    
30.   *   Post:   Return   true   is   the   pointer   is   bad
    
31.   *       or   false   if   otherwise
    
32.   ********************************************
    
33. */
    
34. 
    
35. int   IsReadBadPtr(void   *   ptr_buffer,   unsigned   long   buffer_size)
    
36. {
    
37. struct   sigaction   oldaction,   newaction;
    
38. volatile   char   dummy;
    
39. char   *ptr   =   (char   *)ptr_buffer;
    
40. 
    
41. if   (   !buffer_size   )
    
42. return   0;
    
43. 
    
44.             /*   storing   the   old   signal   environment   and   trapping   SIGSEGV   */
    
45. newaction.sa_handler   =   segv_handler;
    
46. newaction.sa_flags   =   0;
    
47. sigemptyset(   &newaction.sa_mask);
    
48. 
    
49. sigaction(   SIGSEGV,   &newaction,   &oldaction);
    
50. 
    
51. segv_flag   =   0;
    
52. 
    
53.             /*   Storing   the   process   state   so   if   any   failure   happens   
    
54.                   we   can   restore   it   to   the   original   state   */
    
55. if   (   setjmp(jmp_env)   ==   0   )
    
56. {
    
57. /*   testing   the   pointer:   only   the   first   and   the   end   are         needed   here   since   any   failure   to   any   of   this   would           indicate   there   would   an   error   on   the   entire   range   */
    
58. dummy   =   ptr[0];
    
59. dummy   =   ptr[buffer_size-1];
    
60. }
    
61. 
    
62.             /*   restoring   the   original   signal   environment   */
    
63. sigaction(SIGSEGV,   &oldaction,   NULL);
    
64. 
    
65. return   segv_flag;
    
66. }
    
67. 
    
68. int   main()
    
69. {
    
70. char   *testptr,c;     //   testptr[10]，结果将是Ok   read   Ptr
    
71. 
    
72. if   (   IsReadBadPtr(testptr,   10))
    
73. printf( "   Bad   read   Ptr\n ");
    
74. else
    
75. printf( "   Ok   read   Ptr\n ");
    
76. fflush(stdout);
    
77. return   0;
    
78. }
    

复制代码

dremi

这个比较简单，可以通过检查该变量地址是否有可写属性
通过分析/proc/pid/maps文件可以得出

下面是实现：

1. int check_mem_wrtieable(unsigned long addr, int len)
   
2. {
   
3.         pid_t pid ;
   
4.         char namemaps[64];
   
5.         unsigned long ulStartAddr, ulEndAddr, ulLastAddr;
   
6.         char access , buff[1024];
   
7.         FILE *pmap;
   
8.        
   
9.         pid = getpid();
   
10.         sprintf(namemaps, "/proc/%d/maps", pid);
    
11.        
    
12.         pmap = fopen(namemaps, "rb");
    
13.         if(pmap)
    
14.         {
    
15.                 while(1)
    
16.                 {
    
17.                         if(NULL == fgets(buff, sizeof(buff)-1, pmap))
    
18.                         {
    
19.                                 if(feof(pmap)) break;
    
20.                                 else
    
21.                                 {
    
22.                                         fclose(pmap);
    
23.                                         return 0;
    
24.                                 }
    
25.                         }
    
26.                        
    
27.                         sscanf(buff, "%x-%x %*c%c", &ulStartAddr, &ulEndAddr, &access);
    
28.                        
    
29.                         if(addr <= ulEndAddr && addr >= ulStartAddr)
    
30.                         {
    
31.                                 if('w' != access)
    
32.                                 {
    
33.                                         fclose(pmap);
    
34.                                         return 0;
    
35.                                 }
    
36.                                
    
37.                                 if((addr + len) < ulEndAddr)
    
38.                                 {
    
39.                                         fclose(pmap);
    
40.                                         return 1;
    
41.                                 }
    
42.                                 else // 检查后面部分地址
    
43.                                 {
    
44.                                         ulLastAddr = ulEndAddr;
    
45.                                         len = len - (ulEndAddr - addr);
    
46.                                         addr = ulLastAddr;
    
47.                                 }
    
48.                         }
    
49.                         printf("%#x %#x %c\n", ulStartAddr, ulEndAddr, access);       
    
50.                 }
    
51.         }
    
52.        
    
53.         fclose(pmap);
    
54.         return 0;
    
55. }

复制代码

qunying_cu

感觉楼主想错了方向， 这种情况下，程序COREDUMP是最好的。不然，如果指针本身不合法(例如，指向了刚刚释放了的内存），这些判断也白搭。