UDP编程

UDP编程

UDP编程流程：

UDP编程除soket、listen、bind、connect、send、recv等特定网络相关函数外，收发数据采用了新的收发函数在send和recv的基础上进行扩充。

  • UDP数据新的函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <sys/types.h>
#include <sys/socket.h>

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);	// dest_addr用于传入数据

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen); // 提供 src_addr用于接收数据
//返回值：成功：收到的字节数，失败：-1

// flags:
// 般填写0,此时和read()
// MSG_DONTWAIT: 非阻塞版本
// MSG_00B: 于发送TCP类型的带外数据(out-of-band)，异常数据
// MSG_PEEK: 可以成功读数据，但流的偏移量不会改变

//第二个参数需传入类型：
struct sockaddr
{
    sa_family_t sa_family; // 2字节
    char sa data [14]; // 14字节
}；
//第二个参数实际传入类型，填充好后需强制转换成struct sockadd：
 struct sockaddr_in 
 {
     sa_family_t    sin_family; /* 网络族ipv4/ipv6 ,  AF_INET（ipv4） / AF_INETE6（ipv6） / AF_PACKET（原始套接字）*/
     in_port_t      sin_port;   /* 端口号网络（字节序） */
     struct in_addr sin_addr;   /* 32位ip（网络字节序）， 通过int inet_pton(int af, const char *src, void *dst);得到*/
 };
//32位网络字节序ip结构体
struct in_addr 
{
    uint32_t s_addr;     /* address in network byte order */
};

MSG_PEEK方式读数据：常用在对一包数据进行协议长度检查，看是否已经接收到一包完整的数据，下次再调用recv（）读数据还是会读到和上次一样的数据，因为上次以MSG_PEEK方式读数据，文件描述符（流）的偏移量并没有改变。

  • UDP网络编程模型：循环模式

服务端编程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define SERV_PORT 9999

void cli_data_handle(void *argc);

int main (int argv, char **argc)
{
    int fd;
    struct sockaddr_in sin = {0};

    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_DGRAM, 0); //创建数据报式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    // 优化3：运行绑定地址快速重用
    int b_reuse = 1;
    setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof(int));

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(SERV_PORT); // 端口号转成网络字节序
    
	// 优化1：让服务器能绑定在任意的ip上
	sin.sin_addr.s_addr = htonl(INADDR_ANY); // INADDR_ANY其实等于-1，这样整形所有的位都是1
    
    /* 绑定套接字 */
    if (bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)  
    {
        perror("bind");
        exit(-1);
    }

    #define BUF_SIZE 1024
    char buf[BUF_SIZE];
    struct sockaddr_in cin = {0};
    socklen_t clen = sizeof(cin);
    char ipv4_addr[16];

    /* 数据收发循环 */
    while(1)
    {
        bzero (buf, BUF_SIZE); // 数组清零
        if (recvfrom(fd, buf, BUF_SIZE - 1, 0, (struct sockaddr *)&cin, &clen) < 0)
        {
            perror("recvfrom");
            continue;
        }

        if (!inet_ntop(AF_INET, (void *)&cin.sin_addr, ipv4_addr, clen))
        {
            perror("inet_ntop");
            exit(-1);
        }
        printf("revc client(%s:%d):%s\n", ipv4_addr, ntohs(sin.sin_port), buf);
    
        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
            printf("Client(%s:%d) is exiting!\n", ipv4_addr, ntohs(sin.sin_port));
        }
    }

    close(fd);
}

客户端编程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

void usage(char *s)
{
    printf("\n%s serv_ip serv_port", s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
    int fd;
    short port;
    struct sockaddr_in sin = {0};
    
    if (argc < 3)
    {
        usage(argv[0]);
        exit(1);
    }

    port = atoi(argv[2]);
    if (port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_DGRAM, 0); //创建数据报套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(port); // 端口号转成网络字节序
    sin.sin_addr.s_addr = inet_addr(argv[1]); // 将点斜式ip转成整形ip，内部自动转成网络字节序

    /* 读写套接字 */
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];

    while (1)
    {
        bzero (buf, BUF_SIZE); // 数组清零
        if (fgets(buf, BUF_SIZE, stdin) < 0)
        {
            perror("fgets");
            continue;
        }

        sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&sin, sizeof(sin));

        if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
        {
            printf("Client is exiting!\n");
            break;
        }
    }

    close (fd);
    return 0;
}

运行结果：

UDP编程和TCP编程的区别：

1.UDP不是面向连接的，所以服务器不需要为每个连接专门创建一个线程收发数据。

2.UDP没有connect、listen函数，用来建立连接。

3.UDP发送数据必须携带对方的ip和端口信息，告诉内核该包数据发送的具体位置信息。

4.客户端关闭了，服务器不用做任何处理，而TCP需要关闭为这个客户端创建的进程或线程。

5.UDP和TCP在传输层是相互独立的，所以端口号也是独立的，一台设备一个端口可以同时被绑定UDP和TCP服务端。

6.UDP发送数据不会管对方是否收到，数据给到内核，内核通过传输层–>网络层–>链路层–>网卡–>n….个路由器–>服务端机器的硬件。

7.UDP客户端和服务端的区别不是很大，相比UDP客户端服务端唯一多了一步绑定本机的ip和端口，从而能过让客户端通过这个ip和端口号找到自己。如果要实现双向通信就要求两个设备都要绑定各自的ip和端口号，互为服务器和客户端。

8.UDP不用等待确认,没有实际的发送缓冲区,发送的时候直接往内核送数据,所以UDP协议中不存在发送缓冲区满的情况,在UDP套接字上执行的写操作永远都不会阻塞。

源码地址：http://gitea.880755.xyz/private/UDP_Demo.git

展开全文 >>

IO多路复用网络编程（终极篇）

I/O多路复用

在UNIX/Linux下主要有4种I/O模型:

阻塞I/O:

  • 最常用
  • 同步通信模型
  • 阻塞I/O模式是最普遍使用的I/O模式,大部分程序使用的都是阻
    塞模式的I/O。
  • 缺省情況下,套接字建立后所处于的模式就是阻塞1/0模式。
  • 前面学习的很多读写函数在调用过程中会发生阻塞。
    -读操作中的read、recv、 recvfrom
    -写操作中的write、send，（sendto不阻塞）
    -其他操作: accept、connect
  • 阻塞I/O会导致调用该函数的进程或线程会被阻塞，不会被内核进行调度
  • 处理不当会造成进程、线程被永远阻塞

以read函数为例:

  • 进程调用read函数从套接字上读取数据,当套接字的接收缓冲区中还没有
    数据可读,函数read将发生阻塞。
    它会一直阻塞下去,等待套接字的接收缓冲区中有数据可读。
  • 经过一段时间后,缓冲区内接收到数据,于是内核便去唤醒该进程,通过
    read访问这些数据。
  • 如果在进程阻塞过程中,对方发生故障,那这个进程将永远阻塞下去。

非阻塞I/O:

  • 可防止进程阻塞在I/O操作上,需要轮询
  • 同步通信模型
  • 当我们将一个套接字设置为非阻塞模式,我们相当于告诉了系统内核: 当我请
    求的1/0操作不能够马上完成,你想让我的进程进行休眠等待的时候,不要这么
    做,请马上返回一个错误给我。
  • 当一个应用程序使用了非阻塞模式的套接字,它需要使用一个循环来不停地测试
    是否一个文件描述符有数据可读(称做polling )。
  • 应用程序不停的polling内核来检查是否1/0操作已经就绪。这将是一个极浪费
    CPU资源的操作。
  • 这种模式使用中不普遍。

非阻塞I/O模式就和普通的全局变量、普通的缓冲区没有什么区别，需要不停的查询，缓冲区没有数据的时候cpu也要去运行查询的操作，极其浪费cpu资源。

信号（事件）驱动I/O:

  • 一种异步通信模型

I/O多路复用:

  • 允许同时对多个I/O进行控制
  • 同步通信模型

IO多路复用的原理：当一个进程中有多个需要阻塞的文件描述符同时运行的时候，就把需要阻塞的这些文件描述符加到一个集合里面，当一个或多个阻塞的函数有数据到来是就返回集合阻塞函数，然后再查询具体是哪个阻塞文件描述符有数据到来了，处理完数据后继续集合阻塞。

  • 基本常识：

linux中每个进程默认情况下,最多可以打开1024个文件,最多有1024个文件描述
符
文件描述符的特点:
1.非负整数
2.从最小可用的数字来分配
3.每个进程启动时默认打开0, 1,2三个文件描述符

多路复用针对不止套接字fd,也针对普通的文件描述fd

linux的文件描述符集合图示：

IO多路复用就是围绕着fd_set这个结构体做操作

IO多路复用相关函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void FD_ZERO(fd_set *fdset); // 对集合清零
void FD_SET(int fd, fd_set *fdset); // 把fd加入到集合
void FD_CLR(int fd, fd_set *fdset); // 把fd从集合中移除
int FD_ISSET(int fd, fd_set *fdset); // 判断fd是否在集合中

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);
// nfds：最大的文件描述符加一 
// readfds：读集合
// writefds：写集合，一般不会用到写集合，填NULL
// exceptfds：异常集合（带外数据），一般也不会用，填NULL
// 集合最大阻塞时间：
struct timeval 
{
    long    tv_sec;         /* 秒 */
    long    tv_usec;        /* 微秒 */
};

注：select()退出后，集合表示的是有数据的集合，有数据的集合是原来传入集合的子集。

通过 if (FD_ISSET(fd, fdset)) 判断，fd是否在这个有数据的集合中。

如果fd是监听套接字：有新的客户端连接。

如果fd是已连接客户端的套接字：客户端有数据过来。

示例程序：

服务端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
//伪代码：
#include "list.h"
#include <cstd_header.h>
     
int main()
{
	/* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字
    /* 运行绑定地址快速重用 */
    setsockopt();
    
    /* 绑定套接字 */
    bind(fd, (struct sockaddr *)&sin, sizeof(sin));
    
    /* 把主动套接字变成被动套接字 */
    listen(fd, 5);
    
    while (1)
    {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds); // 添加fd到集合rfds
        FD_SET(fd, &rfds);
        
        for (i = 1; i <= client_len; i++) // 遍历已连接的客户端链表添加fd到rdf
        {
            info = list_get_info_by_num(L, i);
            FD_SET(info->fd, &rfds);
        }
        
        // 阻塞等待集合rfds中是否有数据到来，注意max_fd要加一，是数组的个数是max_fd + 1，最大下标是max_fd
        select(max_fd + 1, &rfds, NULL, NULL, NULL); 
        
        if (FD_ISSET(fd, &rfds))  // 判读fd是否有数据到来，新的客户端连接
        {
            if (accept_client(fd, L) < 0) // 添加新的客户端信息到链表
            {
                printf("no newclient connect\n");
                continue;
            }
        }
		
        // 如果链表被删除，list_get_length()可能在循环时变化，需要实时计算
        for (i = 1; i <= list_get_length(L); i++) // 遍历已连接的客户端链表判断fd是否有在线客户端数据来了
        {
            info = list_get_info_by_num(L, i);
            if (FD_ISSET(info->fd, &rfds))
            {
                cli_data_handle(info, L); // 进行数据的接收和转发
            }
        }
    }
    
    close(fd);
    return 0;
}

客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <sys/time.h>

void usage(char *s)
{
    printf("\n%s serv_ip serv_port", s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\n");
}

int main (int argc, char **argv)
{
    int fd;
    short port;
    struct sockaddr_in sin = {0};
    
    if (argc < 3)
    {
        usage(argv[0]);
        exit(1);
    }

    port = atoi(argv[2]);
    if (port < 5000)
    {
        usage(argv[0]);
        exit(1);
    }
    /* 创建套接字 */
    fd = socket(AF_INET, SOCK_STREAM, 0); //创建流式套接字，fd：套接字文件描述符
    if (fd < 0)
    {
        perror("socket");
        exit(-1);
    }

    /* 初始化 struct sockaddr_in */
    sin.sin_family = AF_INET; // 网络族
    sin.sin_port = htons(port); // 端口号转成网络字节序
    sin.sin_addr.s_addr = inet_addr(argv[1]); // 将点斜式ip转成整形ip，内部自动转成网络字节序

    /* 连接服务器 */
    if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(-1);
     }
    printf("conect sever success\n");

    /* 读写套接字 */
    #define BUF_SIZE 1024
    char buf[BUF_SIZE];
    int ret = -1;
    int max_fd = -1;
    fd_set rfds;
    struct timeval tout;

    while (1)
    {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds); // 添加fd到集合rfds
        FD_SET(fd, &rfds);

        max_fd = fd;
        tout.tv_sec = 10;
        tout.tv_usec = 0;
        select(max_fd + 1, &rfds, NULL, NULL, &tout);   // 阻塞10s等待集合rfds中是否有数据到来，注意max_fd要加一，是数组的个数是max_fd + 1，最大下标是max_fd

        if (FD_ISSET(0, &rfds))  // 判读标准输入fd是否有数据到来
        {
            bzero (buf, BUF_SIZE); // 数组清零
            do
            {
                ret = read(0, buf, BUF_SIZE -1); // 预留一个保存‘/0’ 
            } while (ret < 0 && EINTR == errno);

            if (ret < 0 || !ret)
            {
                perror("read stdin error");
                continue;
            }

            ret = write(fd, buf, strlen(buf));
            if (ret < 0)
            {
                perror("read stdin error");
                continue;
            }
            
            if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
            {
                printf("Client is exiting!\n");
                break;
            } 
        }
        
        if (FD_ISSET(fd, &rfds)) // 判断套接字是否有数据到来
        {
            bzero (buf, BUF_SIZE); // 数组清零
            do
            {
                ret = read(fd, buf, BUF_SIZE -1); // 预留一个保存‘/0’
            } while (ret < 0 && EINTR == errno);

            if (ret < 0)
            {
                perror("read stdin error");
                continue;
            }
            else if (!ret)
            {
                printf("sever is colse\n");
                break;
            }
            printf("recv serv data: %s\n", buf);

            if (!strncasecmp(buf, "quit", 4)) // 不区分大小写的字符串比较
            {
                printf("Server Client is exiting!\n");
                break;
            }
        }
    }

    close (fd);
    return 0;
}

运行结果：

1.文件描述符集合：把多个需要阻塞等待的文件描述符假如到一个数组当中，当有其中一个或多个文件描述符有数据可读时，进程会被唤醒运行，然后找出是哪个文件描述符再处理这个文件描述符的数据。

2.文件描述符集合不光只对网络编程可用，对所有的文件io都可以用。

3.文件描述符使进程中多个需要阻塞的地方变成一个地方阻塞，解决了以往进程中有多个阻塞等待文件描述符数据的时候需要开多个进程或线程的问题。

源码地址：http://gitea.880755.xyz/private/TCP_IO_Demo.git

展开全文 >>

TCP_IP协议原理

TCP/IP协议原理

  • wireshark的工作原理

  • 抓取指定网卡端口数据

此网卡是windows下和linux虚拟机在一个局域网的

  • windows下使用工具作为客户端连接linux虚拟机上的服务器

在客户端发送一个数据给服务器，wireshark抓到TCP数据包

  • 常用调试测试工具

使用telnet测试TCP服务器端
使用lsof
使用tcpdump
使用netstat
使用sniffer
使用wireshark（全平台）
Chariot
…
SmartBit-硬件

TCP/P协议网络封包格式

网络接口物理层：主要以MAC地址传输

网络层：主要以IP地址传输

传输层：主要以端口号传输

Ethernet header:

MTU：以太网MTU=1500

MSS（maxium segment size）：网络类型、线路、系统相关特性

  • 1.以太网头

以太网头示例图：

  • 2.IP头

ip头示例图：

包的碎片化过程：

  • 3.TCP头

TCP是一种面向连接的，可靠的数据传输，之前的链路层和网络层都是一种尽力传输。

  • TCP可靠传输图示

1.通过确认和重发机制：TCP数据给每个字节都编了一个号码，所以数据最小单元为字节。例如：一个包可以带1-999字节，滑动窗口在1-999编号上。

2.发送时在当前offset数据位置发送window窗口大小的数据。

3.如果接收到的ack是offset + window + 1，代表数据发送成功，如果是小于offset + window +1的那么offset移动到接收到的数据位置，数据窗口向后滑，代表有数据需要被重复。

  • TCP面向连接示例图

TCP完整工作过程图示：

linux系统Time_wait:如果套接字没有通过close(fd)关闭，进程直接被信号退出，那么就不会执行close(fd),这时内核不会马上释放套接字，要等待time_wait超时时间到后才会关闭套接字。linux、unix系统time_wait时间根据系统30s到2分钟。

展开全文 >>

SQLite数据库

SQLite数据库

  • 数据(Data)

能够输入计算机并能被计算机程序识别和处理的信息集合

  • 数据库(Database)

数据库是在数据库管理系统管理和控制之下,存放在存储介质上的数据集合

  • 关系型数据库

在建立表格的时候数据与数据之间是依靠它的一种逻辑关系建立存储关系的数据库

基于嵌入式的数据库

  • 基于嵌入式Linux的数据库主要有SQLite, Firebird, Berkeley DB,extremeDB
  • Firebird是关系型数据库,功能强大,支持存储过程、SQL兼容等
  • sQLite关系型数据库,体积小,支持ACID事务
  • Berkeley DB中并没有数据库服务器的概念,它的程序库直接链接到应用程序中
  • extremeDB是内存数据库,运行效率高

SQLite介绍：

  • sQLite的源代码是c,其源代码完全开放.soLite第一个Alpha版本诞生于2000年5月。他是一个轻量级的嵌入式数据库。
  • sQLite有以下特性:

1.零配置一无需安装和管理配置;
2.储存在单一磁盘文件中的一个完整的数据库;
3.数据库文件可以在不同字节顺,的机器间自由共享;
4.支持数据库大小至2TB;
5.足够小,全部源码大致3万行c代码, 250KB;
6.比目前流行的大多数数据库对数据的操作要快;

电影、图片等打文件存在文件系统下，表格文字等内容才是放在数据库。

SQLite安装和相关shell命令

所有的数据库使用的都是sql命令

.开头的是系统命令

1
2
3
4
5
6
sqlite3 # 进入数据库程序
.quite  # 退出
.help   # 帮助
.schema # 查看表的结构图
.databases # 查看打开的数据库路径
.table  # 查看数据库中已有的表格

sql命令以分号结尾

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 创建一个数据库
sqlite student.db 

# 创建一张表
# stu :表名
# id、name、score：字段名称
# Integer、char：字段类型
create table stu(id Integer, name char, score Integer); 

# 插入一条字段
insert into stu values(1001, 'zhangsan', 80); 

# 查询表的所有字段
select * from stu;

# 指定部分字段插入一条字段
# sqlite不会检查类型是否匹配，score：应该是Integer性这里输入的是一个char型？
insert into stu (name, score)values(1003, "wangwu"); 

# 查询部分字段name
select name from stu;

# 查询部分字段分数等于80的
select * from stu where score=80;

# 查询部分字段带两个条件
# 多个条件需同时满足用and连接
# 多个条件只需满足其中一个用or连接
select * from stu where score=80 and id=1001;
select * from stu where score=80 or name="lisi";

# 删除一条记录
# 和select一样可以使用and和or
delete from stu whrer id=1003

# 删除一个表格
delete from stu

# 更新一条记录中一个字段
# 将1001学生的名字改成wangwu 
update stu set name='wangwu' where id=1001;

# 更新一条记录中多个字段
# 用，隔开
update stu set name='wangwu', score=88 where id=1001;

# 为表格添加一列新的字段，column:列
alter table stu add column address char;

# sqlite不支持直接删除一列
# 需要，先创建一个新表，复制旧表需要的字段，然后删除旧表，再把新表改成旧表的名字
create table stu1 as select id, name,score from stu; # 根据旧表创建新表并复制指定字段的数据
drop table stu; # 删除旧表
alter table stu1 rename to stu; # 重命名新表


表格直接理解成excel表格，sqlite不会进行严格的类型匹配，sqlite不支持直接删除一列。

SQLite编程接口

  • C语言sqlite基本操作api
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
int sqlite3_open(char *path, sqlite3 **db);
//功能:打开sqlite数据库
//path:数据库文件路径
//d:指向salite句柄的指针
//返回值:成功返回0,失败返回错误码(非零值)

int sqlite3 close(sqlite3 *db);
//功能:关闭salt效据库
//返回值:成功返回0,失败返回错误码
    
const char *sqlite3_errmg(sqlite3 *db);
//返回值：返回错误信息1首地址

int sqlite3_exec(
sqlite3*db,      /* An open database */
const char *sql, /* SQL to be evaluated*/
int (*callback) (void* arg, int, char**, char**), /* Callback function */
void * arg,     /* 1st argument to callback */
char **errnsg   /* Error msg written here */
);
//功能:执行一条sq语句,将shell中的sql命令关联到C语言了
//参数, db数据库操作句柄
//sql一条sgli句
//callback竭函数, 只有sql为查询语句的时候,才会执行此语句。
//arg表示的是给回调函数传递参数
//errnsg 错误消息
//返回值:成功SQLITE_OK

typedef int (*sqlite3_callback)(void *para, int f_num, char**f_value, char ** f_name) ;
//功能:每找到一条记录自动执行一次回调函数
//para:传递给回调函数的参数
//f_num:记录中包含的字段数目
//f_value:包含每个字段值的指针数组
//f_name:包含每个字段名称的指针数组
//返回值:成功返回0,失败返回-1

/* 不使用回调函数执行S0L语句 */
int sqlite3_get-table(sqlite3 *db, const char *sal, char *resultp,
int*nrow, int *ncolumn, char *errmsg);
//功能:执行SQL操作
//db:数据库句柄
//sql: sql语句
//resultp:用来指向sQ1执行结果的指针
//nrow:满足条件的记录的数目
//ncolumn:每条记录包含的字段数目
//errmsg:错误信息指针的地址
//成功返回0，失败返回错误码

更多的api接口函数可以查询SQLite api接口文档

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
#include <stdio.h>
#include <sqlite3.h>
#include <stdlib.h>

#define DATABASE "stu.db"

int insert(sqlite3 *db)
{
    int id;
    char name[20] = {};
    int score;
    char sql[100] = {};
    char *errmsg;
    printf("intput id:");
    scanf("%d", &id);
    getchar();
    printf("input name:");
    scanf("%s", name);
    getchar();
    printf("intput score:");
    scanf("%d", &score);
    getchar();
    sprintf(sql, "insert into stu values(%d,'%s',%d);", id, name, score); //拼接语句

    if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
    {
        printf("%s\n", errmsg);
        return -1;
    }

    return 0;
}

int delete (sqlite3 *db)
{
    int id;
    char sql[100] = {};
    char *errmsg;
    printf("intput id:");
    scanf("%d", &id);
    getchar();
    sprintf(sql, "delete from stu where id=%d;", id);

    if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
    {
        printf("%s\n", errmsg);
        return -1;
    }

    return 0;
}

int update(sqlite3 *db)
{
    int id;
    char name[20] = {};
    int score;
    char sql[100] = {};
    char *errmsg;
    printf("intput update id:");
    scanf("%d", &id);
    getchar();
    printf("intput update score:");
    scanf("%d", &score);
    getchar();
    sprintf(sql, "update stu set score = %d where id = %d;", score, id);

    if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
    {
        printf("%s\n", errmsg);
        return -1;
    }

    return 0;
}

int callback(void *para, int f_num, char **f_value, char **f_name)
{
    int i = 0;

    for (i = 0; i < f_num; i++)
    {
        printf("%-11s", f_value[i]);
    }

    printf("\n");
    return 0;
}

/*int search(sqlite3 *db)  //采用回调方式查询
{
    char sql[100] = {};
    char *errmsg;

    sprintf(sql,"select * from stu;");
    if(sqlite3_exec(db,sql,callback,NULL,&errmsg) != SQLITE_OK)
    {
        printf("%s\n",errmsg);
        return -1;
    }
}*/

int search(sqlite3 *db)     // 不采用回调查询
{
    char sql[100] = {};
    char *errmsg;
    char **resultp;
    int nrow, ncolumn, i, j, index;
    sprintf(sql, "select * from stu;");

    if (sqlite3_get_table(db, sql, &resultp, &nrow, &ncolumn, &errmsg) != SQLITE_OK)
    {
        printf("%s\n", errmsg);
        return -1;
    }

    for (j = 0; j < ncolumn; j++)   //输出表头，若不需输出表头，可将此循环注释掉
    {
        printf("%-11s ", resultp[j]);
    }

    putchar(10);
    index = ncolumn;  //跨过表头，直接输出记录

    for (i = 0; i < nrow; i++)
    {
        for (j = 0; j < ncolumn; j++)
        {
            printf("%-11s ", resultp[index++]);
        }

        putchar(10); //换行符
    }

    sqlite3_free_table(resultp);//get_table用完后应该释放此临时开辟的空间
    return 0;
}

int main(int argc, const char **argv)
{
    sqlite3 *db;
    char *errmsg;
    int cmd;

    if (sqlite3_open(DATABASE, &db) != SQLITE_OK)
    {
        printf("%s\n", sqlite3_errmsg(db));
        return -1;
    }

    //创建数据库表
    if (sqlite3_exec(db, "create table stu(id int primary key not null, name text not null,score int not null);", NULL,
                     NULL, &errmsg) != SQLITE_OK)
    {
        printf("%s\n", errmsg);
    }

    printf("input cmd:");

    while (1)
    {
        printf("\n");
        printf("******************************\n");
        printf("1.insert 2.delete 3.search 4.update 5.quit\n");
        printf("******************************\n");
        printf("\n");
        scanf("%d", &cmd);
        getchar();

        switch (cmd)
        {
        case 1:
            insert(db);
            break;

        case 2:
            delete (db);
            break;

        case 3:
            search(db);
            break;

        case 4:
            update(db);
            break;

        case 5:
            sqlite3_close(db);
            exit(0);

        default:
            printf("error command\n");
        }
    }

    return 0;
}

编译需要链接sqlite3库：gcc sqlite.c -o sqlite -lsqlite3，其实C语言里面编程也是通过sqlite3_exec()来执行sql语句达到操作数据库的目的，和直接在shell输命令没有多大差别。

primary key主键创建时指定一个字段，一张表不能有相同的主键，可以把用户名设置成主键。

sqlite api接口在线文档：https://tool.oschina.net/apidocs/apidoc?api=sqlite

展开全文 >>

linux系统bootloader移植

linux系统bootloader移植

bootloader基本概念

  • Bootloader是硬件启动的引导程序,是运行操作系统的前提;
  • 在操作系统内核或用户应用程序运行之前运行的一小段代码。对软硬件进行相应的初始化和设定,为最终运行操作系统准备好环境;
  • 在嵌入式系统中,整个系统的启动加载任务通常由Bootloader来完成。
  • X86架构中叫BOIS程序，ARM架构中叫bootloader。

bootloader特点

  • Bootloader不属于操作系统,一般采用汇编语言和C语言开发。需要针对特定的硬件平台编写。
  • 在移植系统时,首先为开发板移植Bootloader。
  • Bootloader不但依赖于CPU的体系结构,而且依赖于嵌入式系统板级设备的配置。

bootloader的操作模式

  • 自启动模式:在这种模式下, Bootloader从目标机上的某个固态存储设备
    上将操作系统加载到RAM中运行,整个过程并没有用户的介入。
  • 交互模式:在这种模式下, 目标机上的Bootloader将通过串口或网络等通信手段从开发主机(Host)上下载内核映像和根文件系统映像等到RAM中。可以被Bootloader写到目标机上的固态存储媒质中,或者直接进行系统的引导。也可以通过串口接收用户的命令。
  • 现在大多数ARM、X86、PowerPC架构都是用的U-boot通用引导程序。

1.在上电进入倒数的时候，按任意按键进入交互模式，按pri可以显示环境变量，也是是bootloader的配置信息，否则进入自启动模式。

2.U-boot属于bootloader里面的其中一种

u-boot介绍

  • u-boot (Universal Boot Loader)是德国DENX小组开发的用于多种嵌入式CPU的
    bootloader程序。遵循GPL条款。
  • 从FADSROM, 8xxROM、PPCBOOT, Armboot逐步发展演化而来;
  • 当前版本号:参考Makefile.
  • http://www. denx. de/wiki/U-Boot/WebHome
  • U-boot的特点:
    -代码结构清晰、易于移植(见目录结构)
    -支持多种处理器体系结构(见arch目录)
    -支持众多开发板(目前官方包中有200多种,见board目录)
    -命令丰富、有监控功能
    -支持网络协议、USB,SD等多种协议和设备
    -支持文件系统
    -更新较活跃,使用者多,有助于解决问题

免费开源可深度定制

U-boot命令

  • 命令分类：环境设置、数据传输、存储器访问、加载运行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 1.显示所有环境变量
printenv 

# 2.setenv 设置新的环境变量，临时保存在内存
setenv myboard FS4412  # 设置变量
setenv myboard 		   # 清除变量

# 3.永久保存设置在内存的环境变量
setenvsave

# 4.tftp通过网络下载程序
setenv ethaddr 11:22:33:44:55:66
setenv ipaddr 192. 168. 1. 100
setenv serverip 192. 168. 1. 10
tftp 41000000 application. bin  # 0x41000000下载到内存中的地址，.bin文件名
tftp 41000000 zImage

# 5.protect 对Nor Flash写保护
protect on 0 10000 # 对区间[0x0, 0x10000]进行写保护
protect off 0 10000 # 对上述区间取消写保护
# 6.erase擦除Nor FLASH
erase all   # 擦除FLASH所有的扇区
erase 0 10000   # 把FLASH区间[0xo, 0x10000]擦除

# 6.Nand flash相关命令
nand read addr off size
nand write addr off size
nand erase [clean] [off size]

# 7.emmc相关命令，movi命令
movi init   # 初始化eMMC并显示相关信息
movi read u-boot/kernel addr
movi write u-boot/kernel addr
movi read rootfs addr size
movi write rootfs addr size

# 8.自启动命令
bootcmd [要执行的命令:分隔]
setenv bootcmd tftp 41000000 ulmage\:tftp 42000000 exynos4412-fs4412. dtb\:bootm 41000000-42000000  

# 9.引导内核为内核传参，其中内核和ramdisk通常为mkimage处理过的二进制文件
bootm kernel-addr ramdisk-addr dtb-addr

# 10.跳转到指定地址
go addr

nor flash: 按字节读写，按块擦1->0，字节读程序可以直接执行不用读入内存，eeprom：按字节读写、擦除，nand falsh：按块擦除、读写

U-boot的编译

  • 整个工程通过Makefile来组织编译。顶层目录下的Makefile中包含了开发板的配置信息。从顶层目录开始递归地调用各级子目录下的Makefile,最后链接成u-boot映像。

  • 顶层目录下的Makefile：

它负责u-boot整体配置和编译。
在Makefile中指定使用的交叉工具链。
配置u-boot: make origen _config
编译: make

make -j2: 双核编译，u-boot可以使用脚本编译更方便

E4412这款芯片：三星芯片厂商把初始化时钟、中断等相关代码剥离出去了不开放源码，需要在u-boot.bin之前添加这部分代码。脚本图示：

  • u-boot编译后的文件

u-boot.map U-boot映像的符号表(方便源码跟踪)
u-boot U-Boot映像的ELF格式
u-boot.bin U-Boot映像原始的二进制格式(烧录用)，注意exynos4412需加入BLI
u-boot.srec U-Boot映像的S-Record格式

u-boot.lds U-Boot映像的链接文件，代码重定位

  • 制作SD卡启动盘
1
2
cp u-boot.bin  ..../sdfuse_q
sudo ./mkuboot.sh /dev/sdb
  • u-boot镜像下载

烧录编译产生的镜像u-boot.bin
1.初次或开发板代码损坏不能正常启动时,可采用JTAG工具烧录
2.专用的烧录工具如h-jtag或DNW等
3.在u-boot已经能工作,升级或修正U-boot时,可用U-boot中的命令来烧录
4.其它方式如SD卡 , Fastboot命令
镜像固化位置
1..ROM, NOR FLASH, NAND FLASH EMMC等

u-boot目录结构

  • 平台相关：arch, board, include..

arch : cpu所在目录，按cpu架构区分。

board：单板（底板）外设目录，配置芯片、芯片管脚等。

  • 平台无关：common, net, fs, drivers…

common：共同的部分，例如：各种命令pri、setenv

net：网络相关，例如：TCP/IP协议

fs： 文件系统

drivers： 驱动

  • 工具和文档：tools, doc

U-BOOT启动流程

第一条指令如何执行？性能提升？

  • 初始化哪些硬件,先后顺序如何（汇编）

1.设置为SVC模式获取最高权限、关闭看门狗、中断、MMU、Cache，保证稳定性。

2.时钟、串口、flash、内存，基本硬件初始化。

3.自搬移u-boot到内存。

4.设置栈，跳转第二阶段C代码。

  • 如何加载内核（uImage）（C语言）

1.从flash或SD卡本地可以永久保存的地方读取。

2.将内核拷贝到内存运行。

3.内核接管启动。

u-boot启动过程中3个2：2种语言（汇编、C语言），2次搬移（u-boot、内核），2次初始化（基本芯片内部硬件、外设board板载硬件）

U-BOOT移植方法

1.善用对比软件Beyond
2.选择官方源码版本下载,配置编译
a,指定交叉编译工具链
b.指定cpu和board(参考最类似配置如origen)
c.编译
3.实现串口信息输出
a.跟踪运行路径(led点灯法)
b.串口输出(检查uart初始化相关部分代码见1owlevel init.s)

4.网卡移植(实现能用tftp nfs方便开发调试)
a.寄存器地址
b.参数设置
5.FLASH移植(实现能下载软件到FLASH,产品能离线运行)

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发