Android系统Recovery工作原理之使用update.zip升级过程分析（七）---Recovery服务的核心install_package函数【转】

本文转载自：http://blog.csdn.net/mu0206mu/article/details/7465514

一、       Recovery服务的核心install_package（升级update.zip特有）

和Recovery服务中的wipe_data、wipe_cache不同，install_package()是升级update.zip特有的一部分，也是最核心的部分。在这一步才真正开始对我们的update.zip包进行处理。下面就开始分析这一部分。还是先看图例：

这一部分的源码文件位于：/gingerbread0919/bootable/recovery/install.c。这是一个没有main函数的源码文件，还是把源码先贴出来如下：

1. /*
2. * Copyright (C) 2007 The Android Open Source Project
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. *      http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
16. #include <ctype.h>
17. #include <errno.h>
18. #include <fcntl.h>
19. #include <limits.h>
20. #include <sys/stat.h>
21. #include <sys/wait.h>
22. #include <unistd.h>
23. #include "common.h"
24. #include "install.h"
25. #include "mincrypt/rsa.h"
26. #include "minui/minui.h"
27. #include "minzip/SysUtil.h"
28. #include "minzip/Zip.h"
29. #include "mtdutils/mounts.h"
30. #include "mtdutils/mtdutils.h"
31. #include "roots.h"
32. #include "verifier.h"
33. #define ASSUMED_UPDATE_BINARY_NAME  "META-INF/com/google/android/update-binary"
34. #define PUBLIC_KEYS_FILE "/res/keys"
35. // If the package contains an update binary, extract it and run it.
36. static int
37. try_update_binary(const char *path, ZipArchive *zip) {
38. const ZipEntry* binary_entry =
39. mzFindZipEntry(zip, ASSUMED_UPDATE_BINARY_NAME);
40. if (binary_entry == NULL) {
41. mzCloseZipArchive(zip);
42. return INSTALL_CORRUPT;
43. }
44. char* binary = "/tmp/update_binary";
45. unlink(binary);
46. int fd = creat(binary, 0755);
47. if (fd < 0) {
48. mzCloseZipArchive(zip);
49. LOGE("Can't make %s\n", binary);
50. return 1;
51. }
52. bool ok = mzExtractZipEntryToFile(zip, binary_entry, fd);
53. close(fd);
54. mzCloseZipArchive(zip);
55. if (!ok) {
56. LOGE("Can't copy %s\n", ASSUMED_UPDATE_BINARY_NAME);
57. return 1;
58. }
59. int pipefd[2];
60. pipe(pipefd);
61. // When executing the update binary contained in the package, the
62. // arguments passed are:
63. //
64. //   - the version number for this interface
65. //
66. //   - an fd to which the program can write in order to update the
67. //     progress bar.  The program can write single-line commands:
68. //
69. //        progress <frac> <secs>
70. //            fill up the next <frac> part of of the progress bar
71. //            over <secs> seconds.  If <secs> is zero, use
72. //            set_progress commands to manually control the
73. //            progress of this segment of the bar
74. //
75. //        set_progress <frac>
76. //            <frac> should be between 0.0 and 1.0; sets the
77. //            progress bar within the segment defined by the most
78. //            recent progress command.
79. //
80. //        firmware <"hboot"|"radio"> <filename>
81. //            arrange to install the contents of <filename> in the
82. //            given partition on reboot.
83. //
84. //            (API v2: <filename> may start with "PACKAGE:" to
85. //            indicate taking a file from the OTA package.)
86. //
87. //            (API v3: this command no longer exists.)
88. //
89. //        ui_print <string>
90. //            display <string> on the screen.
91. //
92. //   - the name of the package zip file.
93. //
94. char** args = malloc(sizeof(char*) * 5);
95. args[0] = binary;
96. args[1] = EXPAND(RECOVERY_API_VERSION);   // defined in Android.mk
97. args[2] = malloc(10);
98. sprintf(args[2], "%d", pipefd[1]);
99. args[3] = (char*)path;
100. args[4] = NULL;
101. pid_t pid = fork();
102. if (pid == 0) {
103. close(pipefd[0]);
104. execv(binary, args);
105. fprintf(stdout, "E:Can't run %s (%s)\n", binary, strerror(errno));
106. _exit(-1);
107. }
108. close(pipefd[1]);
109. char buffer[1024];
110. FILE* from_child = fdopen(pipefd[0], "r");
111. while (fgets(buffer, sizeof(buffer), from_child) != NULL) {
112. char* command = strtok(buffer, " \n");
113. if (command == NULL) {
114. continue;
115. } else if (strcmp(command, "progress") == 0) {
116. char* fraction_s = strtok(NULL, " \n");
117. char* seconds_s = strtok(NULL, " \n");
118. float fraction = strtof(fraction_s, NULL);
119. int seconds = strtol(seconds_s, NULL, 10);
120. ui_show_progress(fraction * (1-VERIFICATION_PROGRESS_FRACTION),
121. seconds);
122. } else if (strcmp(command, "set_progress") == 0) {
123. char* fraction_s = strtok(NULL, " \n");
124. float fraction = strtof(fraction_s, NULL);
125. ui_set_progress(fraction);
126. } else if (strcmp(command, "ui_print") == 0) {
127. char* str = strtok(NULL, "\n");
128. if (str) {
129. ui_print("%s", str);
130. } else {
131. ui_print("\n");
132. }
133. } else {
134. LOGE("unknown command [%s]\n", command);
135. }
136. }
137. fclose(from_child);
138. int status;
139. waitpid(pid, &status, 0);
140. if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
141. LOGE("Error in %s\n(Status %d)\n", path, WEXITSTATUS(status));
142. return INSTALL_ERROR;
143. }
144. return INSTALL_SUCCESS;
145. }
146. // Reads a file containing one or more public keys as produced by
147. // DumpPublicKey:  this is an RSAPublicKey struct as it would appear
148. // as a C source literal, eg:
149. //
150. //  "{64,0xc926ad21,{1795090719,...,-695002876},{-857949815,...,1175080310}}"
151. //
152. // (Note that the braces and commas in this example are actual
153. // characters the parser expects to find in the file; the ellipses
154. // indicate more numbers omitted from this example.)
155. //
156. // The file may contain multiple keys in this format, separated by
157. // commas.  The last key must not be followed by a comma.
158. //
159. // Returns NULL if the file failed to parse, or if it contain zero keys.
160. static RSAPublicKey*
161. load_keys(const char* filename, int* numKeys) {
162. RSAPublicKey* out = NULL;
163. *numKeys = 0;
164. FILE* f = fopen(filename, "r");
165. if (f == NULL) {
166. LOGE("opening %s: %s\n", filename, strerror(errno));
167. goto exit;
168. }
169. int i;
170. bool done = false;
171. while (!done) {
172. ++*numKeys;
173. out = realloc(out, *numKeys * sizeof(RSAPublicKey));
174. RSAPublicKey* key = out + (*numKeys - 1);
175. if (fscanf(f, " { %i , 0x%x , { %u",
176. &(key->len), &(key->n0inv), &(key->n[0])) != 3) {
177. goto exit;
178. }
179. if (key->len != RSANUMWORDS) {
180. LOGE("key length (%d) does not match expected size\n", key->len);
181. goto exit;
182. }
183. for (i = 1; i < key->len; ++i) {
184. if (fscanf(f, " , %u", &(key->n[i])) != 1) goto exit;
185. }
186. if (fscanf(f, " } , { %u", &(key->rr[0])) != 1) goto exit;
187. for (i = 1; i < key->len; ++i) {
188. if (fscanf(f, " , %u", &(key->rr[i])) != 1) goto exit;
189. }
190. fscanf(f, " } } ");
191. // if the line ends in a comma, this file has more keys.
192. switch (fgetc(f)) {
193. case ',':
194. // more keys to come.
195. break;
196. case EOF:
197. done = true;
198. break;
199. default:
200. LOGE("unexpected character between keys\n");
201. goto exit;
202. }
203. }
204. fclose(f);
205. return out;
206. exit:
207. if (f) fclose(f);
208. free(out);
209. *numKeys = 0;
210. return NULL;
211. }
212. int
213. install_package(const char *path)
214. {
215. ui_set_background(BACKGROUND_ICON_INSTALLING);
216. ui_print("Finding update package...\n");
217. ui_show_indeterminate_progress();
218. LOGI("Update location: %s\n", path);
219. if (ensure_path_mounted(path) != 0) {
220. LOGE("Can't mount %s\n", path);
221. return INSTALL_CORRUPT;
222. }
223. ui_print("Opening update package...\n");
224. int numKeys;
225. RSAPublicKey* loadedKeys = load_keys(PUBLIC_KEYS_FILE, &numKeys);
226. if (loadedKeys == NULL) {
227. LOGE("Failed to load keys\n");
228. return INSTALL_CORRUPT;
229. }
230. LOGI("%d key(s) loaded from %s\n", numKeys, PUBLIC_KEYS_FILE);
231. // Give verification half the progress bar...
232. ui_print("Verifying update package...\n");
233. ui_show_progress(
234. VERIFICATION_PROGRESS_FRACTION,
235. VERIFICATION_PROGRESS_TIME);
236. int err;
237. err = verify_file(path, loadedKeys, numKeys);
238. free(loadedKeys);
239. LOGI("verify_file returned %d\n", err);
240. if (err != VERIFY_SUCCESS) {
241. LOGE("signature verification failed\n");
242. return INSTALL_CORRUPT;
243. }
244. /* Try to open the package.
245. */
246. ZipArchive zip;
247. err = mzOpenZipArchive(path, &zip);
248. if (err != 0) {
249. LOGE("Can't open %s\n(%s)\n", path, err != -1 ? strerror(err) : "bad");
250. return INSTALL_CORRUPT;
251. }
252. /* Verify and install the contents of the package.
253. */
254. ui_print("Installing update...\n");
255. return try_update_binary(path, &zip);
256. }

下面顺着上面的流程图和源码来分析这一流程：

①ensure_path_mount()：先判断所传的update.zip包路径所在的分区是否已经挂载。如果没有则先挂载。

②load_keys()：加载公钥源文件，路径位于/res/keys。这个文件在Recovery镜像的根文件系统中。

③verify_file()：对升级包update.zip包进行签名验证。

④mzOpenZipArchive()：打开升级包，并将相关的信息拷贝到一个临时的ZipArchinve变量中。这一步并未对我们的update.zip包解压。

⑤try_update_binary()：在这个函数中才是对我们的update.zip升级的地方。这个函数一开始先根据我们上一步获得的zip包信息，以及升级包的绝对路径将update_binary文件拷贝到内存文件系统的/tmp/update_binary中。以便后面使用。

⑥pipe()：创建管道，用于下面的子进程和父进程之间的通信。

⑦fork()：创建子进程。其中的子进程主要负责执行binary（execv(binary,args)，即执行我们的安装命令脚本），父进程负责接受子进程发送的命令去更新ui显示（显示当前的进度）。子父进程间通信依靠管道。

⑧其中，在创建子进程后，父进程有两个作用。一是通过管道接受子进程发送的命令来更新UI显示。二是等待子进程退出并返回INSTALL SUCCESS。其中子进程在解析执行安装脚本的同时所发送的命令有以下几种：

progress  <frac> <secs>：根据第二个参数secs（秒）来设置进度条。

set_progress  <frac>：直接设置进度条，frac取值在0.0到0.1之间。

firmware <”hboot”|”radio”><filename>：升级firmware时使用，在API  V3中不再使用。

ui_print <string>：在屏幕上显示字符串，即打印更新过程。

execv(binary,args)的作用就是去执行binary程序，这个程序的实质就是去解析update.zip包中的updater-script脚本中的命令并执行。由此，Recovery服务就进入了实际安装update.zip包的过程。

下一篇继续分析使用update-binary解析并执行updater-script的过程。