栈回溯技术

转载于：http://blog.csdn.net/yangzhiloveyou/article/details/9042137

1.    前言

段错误、非法地址访问等问题导致程序崩溃的现象屡屡发生，如果能找到发生错误的函数，往往一眼就能看出BUG所在——对于这类比较简单的问题，比如使用空指针进行读写等，利用栈回溯技术可以很快定位。但是对于数组溢出、内存泄漏等问题导致的程序错误，往往隐藏很深，它们并不当场发作，即使我们一步一步跟踪到发生错误的语句时，也经常会让人觉得“这个地方根本不可能出错啊”——错误在很早以前就隐藏下来了，只不过是这个“不可能出错的语句”触发了它。了解栈的作用、堆的实现，可以让我们脑中对程序的运行、函数的调用、变量的操作有个感官的了解，对解决这类问题会有所帮助。

       关键词：堆栈回溯堆实现栈作用

2.    栈的作用

一个程序包含代码段、数据段、BSS段、堆、栈；其中数据段用来中存储初始值不为0的全局数据，BSS段用来存储初始值为0的全局数据，堆用于动态内存分配，栈用于实现函数调用、存储局部变量。比如对于如下程序：

程序1 section.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 int *g_pBuf;

06 int g_iCount = 10;

07

08 int main(int argc, char **argv)

09 {

10     char str[2];

11     g_pBuf = malloc(g_iCount);

12     printf("Address of main       = 0x%08x\n", (unsigned int)main);

13     printf("Address of g_pBuf     = 0x%08x\n", (unsigned int)&g_pBuf);

14     printf("Address of g_iCount   = 0x%08x\n", (unsigned int)&g_iCount);

15     printf("Address of malloc buf  = 0x%08x\n", (unsigned int)g_pBuf);

16     printf("Address of local buf str  = 0x%08x\n", (unsigned int)str);

17

18     return 0;

19 }

使用如下命令编译得到可执行文件section，反汇编文件section.dis：

arm_v5t_le-gcc  -o  section  section.c -static

arm_v5t_le-objdump -D section > section.dis

在PU S980上的linux环境下，这个程序的输出结果为：

Address of main       = 0x000082b8

Address of g_pBuf     = 0x00082998

Address of g_iCount   = 0x00080bd0

Address of malloc buf  = 0x00083f80

Address of local buf str  = 0xbec80b36

其中main函数的地址为0x000082b8，它处于代码段中；全局变量g_pBuf位于BSS段；全局变量g_iCount位于数据段；使用malloc分配出来的内存地址为0x00083f80，它位于堆中；局部变量str数组的开始地址为0xbec80b36，位于栈中。它们的分布图示如下：

图1 程序各段示意图

栈的作用有二：

①     保存调用者的环境——某些寄存器的值、返回地址

②     存储局部变量

现在通过一个简单的例子来说明栈的作用：

程序2 call.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 void A(int a);

06 void B(int b);

07 void C(int c);

08

09 void A(int a)

10 {

11     printf("%d: A call B\n", a);

12     B(2);

13 }

14

15 void B(int b)

16 {

17     printf("%d: B call C\n", b);

18     C(3);

19 }

20

21 void C(int c)

22 {

23     printf("%d: function C\n", c);

24 }

25

26 int main(int argc, char **argv)

27 {

28     A(1);

29     return 0;

30 }

使用如下命令编译得到可执行文件call，反汇编文件call.dis：

arm_v5t_le-gcc -o  call  call.c  -static

arm_v5t_le-objdump -D call > call.dis

此程序的调用关系为main > A > B > C，现在来看看栈如何变化：

图2 函数调用中栈的变化

上图中，main、A、B、C四个函数的栈大小都是16字节，返回地址都存在栈偏移地址为16的地方。我们是如何知道这点的呢？需要阅读反汇编代码：

……

000082b8 <A>:

82b8:       e92d4800        push    {fp, lr}

82bc:       e28db004        add     fp, sp, #4      ; 0x4

82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

82c4:       e50b0008        str     r0, [fp, #-8]

82c8:       e59f0014        ldr     r0, [pc, #20]   ; 82e4 <A+0x2c>

82cc:       e51b1008        ldr     r1, [fp, #-8]

82d0:       eb0003f8        bl      92b8 <_IO_printf>

82d4:       e3a00002        mov     r0, #2  ; 0x2

82d8:       eb000002        bl      82e8 <B>

82dc:       e24bd004        sub     sp, fp, #4      ; 0x4

82e0:       e8bd8800        pop     {fp, pc}

82e4:       00064584        .word   0x00064584

000082e8 <B>:

82e8:       e92d4800        push    {fp, lr}

82ec:       e28db004        add     fp, sp, #4      ; 0x4

82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

82f4:       e50b0008        str     r0, [fp, #-8]

82f8:       e59f0014        ldr     r0, [pc, #20]   ; 8314 <B+0x2c>

82fc:       e51b1008        ldr     r1, [fp, #-8]

8300:       eb0003ec        bl      92b8 <_IO_printf>

8304:       e3a00003        mov     r0, #3  ; 0x3

8308:       eb000002        bl      8318 <C>

830c:       e24bd004        sub     sp, fp, #4      ; 0x4

8310:       e8bd8800        pop     {fp, pc}

8314:       00064594        .word   0x00064594

00008318 <C>:

8318:       e92d4800        push    {fp, lr}

831c:       e28db004        add     fp, sp, #4      ; 0x4

8320:       e24dd008        sub     sp, sp, #8      ; 0x8

8324:       e50b0008        str     r0, [fp, #-8]

8328:       e59f000c        ldr     r0, [pc, #12]   ; 833c <C+0x24>

832c:       e51b1008        ldr     r1, [fp, #-8]

8330:       eb0003e0        bl      92b8 <_IO_printf>

8334:       e24bd004        sub     sp, fp, #4      ; 0x4

8338:       e8bd8800        pop     {fp, pc}

833c:       000645a4        .word   0x000645a4

00008340 <main>:

8340:       e92d4800        push    {fp, lr}

8344:       e28db004        add     fp, sp, #4      ; 0x4

8348:       e24dd008        sub     sp, sp, #8      ; 0x8

834c:       e50b0008        str     r0, [fp, #-8]

8350:       e50b100c        str     r1, [fp, #-12]

8354:       e3a00001        mov     r0, #1  ; 0x1

8358:       ebffffd6        bl      82b8 <A>

835c:       e3a03000        mov     r3, #0  ; 0x0

8360:       e1a00003        mov     r0, r3

8364:       e24bd004        sub     sp, fp, #4      ; 0x4

8368:       e8bd8800        pop     {fp, pc}

上面红色的指令：

“push    {fp, lr}”表示将fp,lr 寄存器进行压栈，同时 sp – 4×2，即向下移动 8 个字节。

“sub     sp, sp, #8”表示将 sp 寄存器的值减 8，即向下移动 8 个字节。

“pop     {fp, pc}”表示弹出栈顶值到 fp， lr 寄存器，同时 sp+4×2，即向上移动 8 个字节。

局部变量也是存储在栈中，当一个函数的局部变量越多，它的栈越大。

从上图可知：栈中保存着函数的返回地址、局部变量等，那么我们可以从这些返回地址来确定函数的调用关系、调用顺序。这就是下节介绍的栈回溯。

3.    栈回溯

将程序2稍加修改，见程序3第23、24、30、32四行：

程序3 stack.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 void A(int a);

06 void B(int b);

07 void C(int c);

08

09 void A(int a)

10 {

11     printf("%d: A call B\n", a);

12     B(2);

13 }

14

15 void B(int b)

16 {

17     printf("%d: B call C\n", b);

18     C(3);

19 }

20

21 void C(int c)

22 {

23     char *p = (char *)c;

24     *p = ‘A’;

25     printf("%d: function C\n", c);

26 }

27

28 int main(int argc, char **argv)

29 {

30      char a;

31     A(1);

32     C(&a);

33     return 0;

34 }

第23、24两行必然导致段错误而使得程序崩溃，linux内核当发现发生段错误时，会打印出栈信息。我们可以使用栈回溯的方法找到发生错误的原因。

使用如下命令编译得到可执行文件stack，反汇编文件stack.dis：

arm_v5t_le-gcc -g -o stack stack.c -static

arm_v5t_le-objdump -dS stack > stack.dis

运行结果如下(注意：如果你是通过telnet来运行程序，可以使用dmesg命令看到这些栈信息)：

/ # ./stack

1: A call B

2: B call C

<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

<1>pgd = c3ca0000

<1>[00000003] *pgd=81b86031, *pte=00000000, *ppte=00000000

<4>

<4>Pid: 662, comm:                stack

<4>CPU: 0

<4>PC is at 0x8338

<4>LR is at 0x830c

<4>pc : [<00008338>]    lr : [<0000830c>]    Not tainted

<4>sp : be897af0  ip : 00000001  fp : be897b04

<4>r10: 00000000  r9 : 00008ac8  r8 : 00008b10

<4>r7 : 00000000  r6 : 00000000  r5 : 00081fe8  r4 : 00000000

<4>r3 : 00000041  r2 : 00000003  r1 : 00000000  r0 : 00000003

<4>Flags: nZCv  IRQs on  FIQs on  Mode USER_32  Segment user

<4>Control: 5317F

<4>Table: 83CA0000  DAC: 00000015

<4>usr stack info

<4>stack mem: sp = be897af0

4> be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 00008354

00004c69 6e757800 000000

<4> be897b24 03be897b 0003be89 000003be 00000003 b4000000 45b40000 0645b400

<4> 000645b4 03000645 00030006 00000300 00000003 14000000 7b140000 897b1400

<4> be897b14 0cbe897b 830cbe89 00830cbe 0000830c a4000083 45a40000 0645a400

……

<4>Backtrace: [<000082fc>] (0x82fc) from [<be897b14>] (0xbe897b14)

<4>Backtrace aborted due to bad frame pointer <000645b4>

<4>Code: e51b3010 e50b3008 e51b2008 e3a03041 (e5c23000)

~ $

上面的蓝色部分

<4>PC is at 0x8338

<4>LR is at 0x830c

表示导致崩溃的指令的地址为0x8338，返回地址为0x830c。一个典型的进程的地址空间为：

~ $ cat /proc/660/maps

00008000-00112000 r-xp 00000000 1f:07 27         /bin/busybox

0011a000-0011b000 rw-p 0010a000 1f:07 27         /bin/busybox

0011b000-001ce000 rwxp 0011b000 00:00 0          [heap]

40000000-40001000 rw-p 40000000 00:00 0

bea24000-bea4e000 rwxp bea24000 00:00 0          [stack]

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x8338 -f -e stack

C

/home/sanya/yjt/bt/stack.c:24

linux-S980:/home/sanya/yjt/bt #

结合此程序的反汇编程序进行回溯：

将PC is at 0x8338所在函数的部分反汇编代码摘录如下：

00008318 <C>:

void C(int c)

{

8318:       e92d4800        push    {fp, lr}

831c:       e28db004        add     fp, sp, #4      ; 0x4

8320:       e24dd010        sub     sp, sp, #16     ; 0x10

8324:       e50b0010        str     r0, [fp, #-16]

char *p = (char *)c;

8328:       e51b3010        ldr     r3, [fp, #-16]

832c:       e50b3008        str     r3, [fp, #-8]

*p = ‘A‘;

8330:       e51b2008        ldr     r2, [fp, #-8]

8334:       e3a03041        mov     r3, #65 ; 0x41

PC->8338:       e5c23000        strb    r3, [r2]

printf("%d: function C\n", c);

833c:       e59f000c        ldr     r0, [pc, #12]   ; 8350 <C+0x38>

8340:       e51b1010        ldr     r1, [fp, #-16]

8344:       eb0003e3        bl      92d8 <_IO_printf>

}

8348:       e24bd004        sub     sp, fp, #4      ; 0x4

834c:       e8bd8800        pop     {fp, pc}

8350:       000645c4        .word   0x000645c4

下面对涉及的每个函数进行分析：

1.  函数C的堆栈：

8318:       e92d4800        push    {fp, lr}

831c:       e28db004        add     fp, sp, #4      ; 0x4

8320:       e24dd010        sub     sp, sp, #16     ; 0x10

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

可知 lr 为 0x0000830c，根据这个地址值，

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x830c -f -e stack

B

/home/sanya/yjt/bt/stack.c:19

linux-S980:/home/sanya/yjt/bt #

在stack.dis中可以再次找到这个地址处于函数B的范围内。

2. 函数B的堆栈：

函数B的汇编指令如下：

void B(int b)

{

82e8:       e92d4800        push    {fp, lr}

82ec:       e28db004        add     fp, sp, #4      ; 0x4

82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

82f4:       e50b0008        str     r0, [fp, #-8]

printf("%d: B call C\n", b);

82f8:       e59f0014        ldr     r0, [pc, #20]   ; 8314 <B+0x2c>

82fc:       e51b1008        ldr     r1, [fp, #-8]

8300:       eb0003f4        bl      92d8 <_IO_printf>

C(3);

8304:       e3a00003        mov     r0, #3  ; 0x3

8308:       eb000002        bl      8318 <C>

}

830c:       e24bd004        sub     sp, fp, #4      ; 0x4

8310:       e8bd8800        pop     {fp, pc}

8314:       000645b4        .word   0x000645b4

由

82e8:       e92d4800        push    {fp, lr}

82ec:       e28db004        add     fp, sp, #4      ; 0x4

82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

可知函数B的堆栈大小为16字节，函数B执行完后的返回地址 lr 存储在其堆栈偏移地址最外层。函数B栈的的数据紧挨着函数C的栈，取出罗列如下：

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

从上面信息可以知道，函数B的返回地址lr 为 000082dc，根据这个地址值，

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x82dc -f -e stack

A

/home/sanya/yjt/bt/stack.c:13

从stack.dis可知处于函数A的地址范围内。

3. 函数A的堆栈：

函数A的汇编指令如下：

void A(int a)

{

82b8:       e92d4800        push    {fp, lr}

82bc:       e28db004        add     fp, sp, #4      ; 0x4

82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

82c4:       e50b0008        str     r0, [fp, #-8]

printf("%d: A call B\n", a);

82c8:       e59f0014        ldr     r0, [pc, #20]   ; 82e4 <A+0x2c>

82cc:       e51b1008        ldr     r1, [fp, #-8]

82d0:       eb000400        bl      92d8 <_IO_printf>

B(2);

82d4:       e3a00002        mov     r0, #2  ; 0x2

82d8:       eb000002        bl      82e8 <B>

}

82dc:       e24bd004        sub     sp, fp, #4      ; 0x4

82e0:       e8bd8800        pop     {fp, pc}

82e4:       000645a4        .word   0x000645a4

由

82b8:       e92d4800        push    {fp, lr}

82bc:       e28db004        add     fp, sp, #4      ; 0x4

82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

可知函数A的堆栈大小为16字节，函数B执行完后的返回地址 lr 存储在其堆栈偏移地址最外层。函数A栈的的数据紧挨着函数B的栈，取出罗列如下：

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

从上面信息可以知道，函数A的返回地址为0x00008370，

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x8370 -f -e stack

main

/home/sanya/yjt/bt/stack.c:32

linux-S980:/home/sanya/yjt/bt #

从stack.dis可知处于函数main的地址范围内。

至此，可以知道main调用A、A调用B、B再调用C时，在函数C中导致程序崩溃。现在认真看一下函数C：

21 void C(int c)

22 {

23     char *p = (char *)c;

24     *p = ‘A’;

25     printf("%d: function C\n", c);

26 }

这个函数太过简单，可以一眼就知道第23、24行代码有问题。但是如果函数C有上千行代码呢？除了睁大眼睛检查C代码外，我们还可以根据它的反汇编码来差错——内核打印出来的栈信息的前面还有些有用的信息：

<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

<1>pgd = c3ca0000

<1>[00000003] *pgd=81b86031, *pte=00000000, *ppte=00000000

<4>

<4>Pid: 662, comm:                stack

<4>CPU: 0

<4>PC is at 0x8338

<4>LR is at 0x830c

<4>pc : [<00008338>]    lr : [<0000830c>]    Not tainted

<4>sp : be897af0  ip : 00000001  fp : be897b04

<4>r10: 00000000  r9 : 00008ac8  r8 : 00008b10

<4>r7 : 00000000  r6 : 00000000  r5 : 00081fe8  r4 : 00000000

<4>r3 : 00000041  r2 : 00000003  r1 : 00000000  r0 : 00000003

<4>Flags: nZCv  IRQs on  FIQs on  Mode USER_32  Segment user

<4>Control: 5317F

现在回过头来看看函数C的反汇编码，从中找出出错的原因：

00008318 <C>:

void C(int c)

{

8318:       e92d4800        push    {fp, lr}

831c:       e28db004        add     fp, sp, #4      ; 0x4

8320:       e24dd010        sub     sp, sp, #16     ; 0x10

8324:       e50b0010        str     r0, [fp, #-16]

char *p = (char *)c;

8328:       e51b3010        ldr     r3, [fp, #-16]

832c:       e50b3008        str     r3, [fp, #-8]

*p = ‘A‘;

8330:       e51b2008        ldr     r2, [fp, #-8]

8334:       e3a03041        mov     r3, #65 ; 0x41

8338:       e5c23000        strb    r3, [r2]

printf("%d: function C\n", c);

833c:       e59f000c        ldr     r0, [pc, #12]   ; 8350 <C+0x38>

8340:       e51b1010        ldr     r1, [fp, #-16]

8344:       eb0003e3        bl      92d8 <_IO_printf>

}

8348:       e24bd004        sub     sp, fp, #4      ; 0x4

834c:       e8bd8800        pop     {fp, pc}

8350:       000645c4        .word   0x000645c4

出错的指令为“8338:       e5c23000        strb    r3, [r2]”，它将寄存器r3的值存到地址(r2)中，只存储1个字节。根据内核打印出来的寄存器值可知r3 : 00000041  r2 : 00000003，写地址为0x03，当然<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

——这不是可写的地址。

阅读汇编代码是件困难的事情，没有其他办法时再用这方法吧。

时间： 2024-10-17 23:15:28

栈回溯技术的相关文章

数据结构之栈（2）——多栈共享技术

多栈共享技术的应用:经常会发生一个程序使用多个栈的情况,然而若使用顺序栈,因为难以对每个栈的空间准确估计,所以会发生有的栈已经溢出,有的栈却还很空闲的状况,解决方案是:可以让多个栈共享一个足够大的数组空间,通过利用栈的动态特性来使其存储空间相互补充,这就是多栈的共享技术 双端栈: 首先申请一个共享的一位数组空间S[M],将两个栈的栈底分别放在数组的两端,即:0,M-1栈顶动态变化,从而多栈共享,提高空间利用率 双端栈的定义 typedef char ElemType; typedef struc

面向全栈的技术管理（多图）

3月25日周六,在中生代和飞马网的技术嘉年华上,斗胆披上吹牛的嫌疑,分享了面向全栈的技术管理,现赘述如下. 研发管理有着广义和狭义的定义,总的来说,研发管理就是在研发体系基础之上,借助信息平台进行的团队建设.流程设计.绩效管理.风险管理.成本管理.项目管理和知识管理等活动. 简单来讲,研发管理是面向结果,过程敏捷的一种实践.作为一名技术管理者,既需要培养团队的ABC,又需要管理你的老板,保持团队的新陈代谢,因为一切都是人的竞争.我曾在GitChat上做过一次分享,具体可以参考<老曹眼中的研发管理

zoj1004-Anagrams by Stack 【栈 回溯】

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4 Anagrams by Stack Time Limit: 2 Seconds      Memory Limit: 65536 KB How can anagrams result from sequences of stack operations? There are two sequences of stack operators which can convert

个人觉得不错的一个线下全栈测试技术沙龙

全栈测试技术沙龙 沙龙时间:9月25日 下午13:30沙龙形式:线下免费主办单位:云层天咨 介绍: 全栈测试工程师的提出,其实只是换了个黄金马甲的测试工程师,但是它重新定义了测试人员的要求,就是啥都懂,这样才能在工作中真正的帮助别人发现问题.定义问题.解决问题,并最终找到质量人员的价值所在. 活动安排:13:00-14:00  签到 14:00-14:45Topic 1 <全栈测试在互联网公司的应用>周超       贝贝网测试经理(14:45-15:00 提问环节) 15:00-15:45T

[leetcode 40. 组合总和 II] 不排序使用哈希表+dfs递归 vs 排序栈+回溯

题目描述 给定一个数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合. candidates 中的每个数字在每个组合中只能使用一次. 说明: 所有数字(包括目标数)都是正整数. 解集不能包含重复的组合. 示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ] 示例 2: 输入

多栈共享技术，双端栈的初始化、进栈、出栈操作

栈的应用非常广泛,经常会出现一个程序中需要同时使用多个栈的情况.若使用顺序栈,会因为对栈空间大小难以准确估计,从而产生有的栈溢出.有的栈空间还很空闲的情况.为了解决这个问题,可以让多个栈共享一个足够大的数组空间,通过利用栈的动态特性来使其存储空间互相补充,这就是多栈的共享技术. 在顺序栈的共享技术中,最常用的是两个栈的共享技术,即双端栈.它主要利用了栈的栈底位置不变,而栈顶位置动态变化的特性. 实现代码如下: #include<iostream> using namespace std; #d

JSer全栈化技术栈推荐(一)——原生移动端是天堂还是泥潭

随着以服务器端的NodeJS.桌面端的Electron和原生移动端React Native为代表的全栈JS迅猛发展,真正生产环境中的"JS/前端技术全栈化"已经逐渐变为可能.尽管在前端以外的领域里,JavaScript还不能取代各领域原本主流语言的地位,但对于大量初创型公司或技术人手不足的团队来说,更低的学习成本本身就是一种极大的优势. 对于技术学习而言,学得好和学得巧同样重要,选对技术栈进行学习,可能会节省大量的时间和精力,更有可能带来更多的机会.因此结合最新的NingJS会议上的趋

迷宫问题（一）-利用栈回溯

本题的前提:起点(1,1), 终点(8,8) #include<stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 20 #define N 10 typedef int Status; typedef char Ma

Python 全栈开发技术

Django https://www.djangoproject.com/ https://docs.djangoproject.com/en/1.10/ http://www.ziqiangxuetang.com/django/django-tutorial.html http://python.usyiyi.cn/django/index.html