blob: 41f053d013775e3530844def9c0ce9880c063564 [file] [log] [blame]
Doug Zongker9931f7f2009-06-10 14:11:53 -07001/*
2 * Copyright (C) 2009 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
Doug Zongkerfbf3c102009-06-24 09:36:20 -070017#include <ctype.h>
Doug Zongker9931f7f2009-06-10 14:11:53 -070018#include <errno.h>
19#include <stdarg.h>
Doug Zongkerfbf3c102009-06-24 09:36:20 -070020#include <stdio.h>
Doug Zongker9931f7f2009-06-10 14:11:53 -070021#include <stdlib.h>
22#include <string.h>
23#include <sys/mount.h>
24#include <sys/stat.h>
25#include <sys/types.h>
Doug Zongkera3f89ea2009-09-10 14:10:48 -070026#include <sys/wait.h>
Doug Zongker9931f7f2009-06-10 14:11:53 -070027#include <unistd.h>
Hristo Bojinovdb314d62010-08-02 10:29:49 -070028#include <fcntl.h>
29#include <time.h>
Doug Zongker9931f7f2009-06-10 14:11:53 -070030
Doug Zongker8edb00c2009-06-11 17:21:44 -070031#include "cutils/misc.h"
32#include "cutils/properties.h"
Doug Zongker9931f7f2009-06-10 14:11:53 -070033#include "edify/expr.h"
Doug Zongker512536a2010-02-17 16:11:44 -080034#include "mincrypt/sha.h"
Doug Zongker9931f7f2009-06-10 14:11:53 -070035#include "minzip/DirUtil.h"
36#include "mtdutils/mounts.h"
37#include "mtdutils/mtdutils.h"
38#include "updater.h"
Doug Zongker512536a2010-02-17 16:11:44 -080039#include "applypatch/applypatch.h"
Doug Zongker8edb00c2009-06-11 17:21:44 -070040
Doug Zongker3d177d02010-07-01 09:18:44 -070041#ifdef USE_EXT4
42#include "make_ext4fs.h"
43#endif
44
45// mount(fs_type, partition_type, location, mount_point)
Doug Zongker9931f7f2009-06-10 14:11:53 -070046//
Doug Zongker3d177d02010-07-01 09:18:44 -070047// fs_type="yaffs2" partition_type="MTD" location=partition
48// fs_type="ext4" partition_type="EMMC" location=device
Doug Zongker512536a2010-02-17 16:11:44 -080049Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -070050 char* result = NULL;
Doug Zongker3d177d02010-07-01 09:18:44 -070051 if (argc != 4) {
52 return ErrorAbort(state, "%s() expects 4 args, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -070053 }
Doug Zongker3d177d02010-07-01 09:18:44 -070054 char* fs_type;
55 char* partition_type;
Doug Zongker9931f7f2009-06-10 14:11:53 -070056 char* location;
57 char* mount_point;
Doug Zongker3d177d02010-07-01 09:18:44 -070058 if (ReadArgs(state, argv, 4, &fs_type, &partition_type,
59 &location, &mount_point) < 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -070060 return NULL;
61 }
62
Doug Zongker3d177d02010-07-01 09:18:44 -070063 if (strlen(fs_type) == 0) {
64 ErrorAbort(state, "fs_type argument to %s() can't be empty", name);
65 goto done;
66 }
67 if (strlen(partition_type) == 0) {
68 ErrorAbort(state, "partition_type argument to %s() can't be empty",
69 name);
Doug Zongker9931f7f2009-06-10 14:11:53 -070070 goto done;
71 }
72 if (strlen(location) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -070073 ErrorAbort(state, "location argument to %s() can't be empty", name);
Doug Zongker9931f7f2009-06-10 14:11:53 -070074 goto done;
75 }
76 if (strlen(mount_point) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -070077 ErrorAbort(state, "mount_point argument to %s() can't be empty", name);
Doug Zongker9931f7f2009-06-10 14:11:53 -070078 goto done;
79 }
80
Stephen Smalley779701d2012-02-09 14:13:23 -050081#ifdef HAVE_SELINUX
82 char *secontext = NULL;
83
84 if (sehandle) {
85 selabel_lookup(sehandle, &secontext, mount_point, 0755);
86 setfscreatecon(secontext);
87 }
88#endif
89
Doug Zongker9931f7f2009-06-10 14:11:53 -070090 mkdir(mount_point, 0755);
91
Stephen Smalley779701d2012-02-09 14:13:23 -050092#ifdef HAVE_SELINUX
93 if (secontext) {
94 freecon(secontext);
95 setfscreatecon(NULL);
96 }
97#endif
98
Doug Zongker3d177d02010-07-01 09:18:44 -070099 if (strcmp(partition_type, "MTD") == 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700100 mtd_scan_partitions();
101 const MtdPartition* mtd;
102 mtd = mtd_find_partition_by_name(location);
103 if (mtd == NULL) {
104 fprintf(stderr, "%s: no mtd partition named \"%s\"",
105 name, location);
106 result = strdup("");
107 goto done;
108 }
Doug Zongker3d177d02010-07-01 09:18:44 -0700109 if (mtd_mount_partition(mtd, mount_point, fs_type, 0 /* rw */) != 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700110 fprintf(stderr, "mtd mount of %s failed: %s\n",
111 location, strerror(errno));
112 result = strdup("");
113 goto done;
114 }
115 result = mount_point;
116 } else {
Doug Zongker3d177d02010-07-01 09:18:44 -0700117 if (mount(location, mount_point, fs_type,
Doug Zongker9931f7f2009-06-10 14:11:53 -0700118 MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") < 0) {
Doug Zongker60babf82009-09-18 15:11:24 -0700119 fprintf(stderr, "%s: failed to mount %s at %s: %s\n",
120 name, location, mount_point, strerror(errno));
Doug Zongker9931f7f2009-06-10 14:11:53 -0700121 result = strdup("");
122 } else {
123 result = mount_point;
124 }
125 }
126
127done:
Doug Zongker3d177d02010-07-01 09:18:44 -0700128 free(fs_type);
129 free(partition_type);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700130 free(location);
131 if (result != mount_point) free(mount_point);
Doug Zongker512536a2010-02-17 16:11:44 -0800132 return StringValue(result);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700133}
134
Doug Zongker8edb00c2009-06-11 17:21:44 -0700135
136// is_mounted(mount_point)
Doug Zongker512536a2010-02-17 16:11:44 -0800137Value* IsMountedFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker8edb00c2009-06-11 17:21:44 -0700138 char* result = NULL;
139 if (argc != 1) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700140 return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700141 }
142 char* mount_point;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700143 if (ReadArgs(state, argv, 1, &mount_point) < 0) {
Doug Zongker8edb00c2009-06-11 17:21:44 -0700144 return NULL;
145 }
146 if (strlen(mount_point) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700147 ErrorAbort(state, "mount_point argument to unmount() can't be empty");
Doug Zongker8edb00c2009-06-11 17:21:44 -0700148 goto done;
149 }
150
151 scan_mounted_volumes();
152 const MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point);
153 if (vol == NULL) {
154 result = strdup("");
155 } else {
156 result = mount_point;
157 }
158
159done:
160 if (result != mount_point) free(mount_point);
Doug Zongker512536a2010-02-17 16:11:44 -0800161 return StringValue(result);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700162}
163
164
Doug Zongker512536a2010-02-17 16:11:44 -0800165Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700166 char* result = NULL;
167 if (argc != 1) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700168 return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700169 }
170 char* mount_point;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700171 if (ReadArgs(state, argv, 1, &mount_point) < 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700172 return NULL;
173 }
174 if (strlen(mount_point) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700175 ErrorAbort(state, "mount_point argument to unmount() can't be empty");
Doug Zongker9931f7f2009-06-10 14:11:53 -0700176 goto done;
177 }
178
179 scan_mounted_volumes();
180 const MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point);
181 if (vol == NULL) {
182 fprintf(stderr, "unmount of %s failed; no such volume\n", mount_point);
183 result = strdup("");
184 } else {
185 unmount_mounted_volume(vol);
186 result = mount_point;
187 }
188
189done:
190 if (result != mount_point) free(mount_point);
Doug Zongker512536a2010-02-17 16:11:44 -0800191 return StringValue(result);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700192}
Doug Zongker8edb00c2009-06-11 17:21:44 -0700193
194
Stephen Smalley779701d2012-02-09 14:13:23 -0500195// format(fs_type, partition_type, location, fs_size, mount_point)
Doug Zongker9931f7f2009-06-10 14:11:53 -0700196//
Stephen Smalley779701d2012-02-09 14:13:23 -0500197// fs_type="yaffs2" partition_type="MTD" location=partition fs_size=<bytes> mount_point=<location>
198// fs_type="ext4" partition_type="EMMC" location=device fs_size=<bytes> mount_point=<location>
Ken Sumrall8f132ed2011-01-14 18:55:05 -0800199// if fs_size == 0, then make_ext4fs uses the entire partition.
200// if fs_size > 0, that is the size to use
201// if fs_size < 0, then reserve that many bytes at the end of the partition
Doug Zongker512536a2010-02-17 16:11:44 -0800202Value* FormatFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700203 char* result = NULL;
Stephen Smalley516e4e22012-04-03 13:35:11 -0400204 if (argc != 5) {
205 return ErrorAbort(state, "%s() expects 5 args, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700206 }
Doug Zongker3d177d02010-07-01 09:18:44 -0700207 char* fs_type;
208 char* partition_type;
Doug Zongker9931f7f2009-06-10 14:11:53 -0700209 char* location;
Ken Sumrall8f132ed2011-01-14 18:55:05 -0800210 char* fs_size;
Stephen Smalley516e4e22012-04-03 13:35:11 -0400211 char* mount_point;
Stephen Smalley779701d2012-02-09 14:13:23 -0500212
Stephen Smalley779701d2012-02-09 14:13:23 -0500213 if (ReadArgs(state, argv, 5, &fs_type, &partition_type, &location, &fs_size, &mount_point) < 0) {
214 return NULL;
215 }
Doug Zongker9931f7f2009-06-10 14:11:53 -0700216
Doug Zongker3d177d02010-07-01 09:18:44 -0700217 if (strlen(fs_type) == 0) {
218 ErrorAbort(state, "fs_type argument to %s() can't be empty", name);
219 goto done;
220 }
221 if (strlen(partition_type) == 0) {
222 ErrorAbort(state, "partition_type argument to %s() can't be empty",
223 name);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700224 goto done;
225 }
226 if (strlen(location) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700227 ErrorAbort(state, "location argument to %s() can't be empty", name);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700228 goto done;
229 }
230
Stephen Smalley516e4e22012-04-03 13:35:11 -0400231 if (strlen(mount_point) == 0) {
Stephen Smalley779701d2012-02-09 14:13:23 -0500232 ErrorAbort(state, "mount_point argument to %s() can't be empty", name);
233 goto done;
234 }
Stephen Smalley779701d2012-02-09 14:13:23 -0500235
Doug Zongker3d177d02010-07-01 09:18:44 -0700236 if (strcmp(partition_type, "MTD") == 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700237 mtd_scan_partitions();
238 const MtdPartition* mtd = mtd_find_partition_by_name(location);
239 if (mtd == NULL) {
240 fprintf(stderr, "%s: no mtd partition named \"%s\"",
241 name, location);
242 result = strdup("");
243 goto done;
244 }
245 MtdWriteContext* ctx = mtd_write_partition(mtd);
246 if (ctx == NULL) {
247 fprintf(stderr, "%s: can't write \"%s\"", name, location);
248 result = strdup("");
249 goto done;
250 }
251 if (mtd_erase_blocks(ctx, -1) == -1) {
252 mtd_write_close(ctx);
253 fprintf(stderr, "%s: failed to erase \"%s\"", name, location);
254 result = strdup("");
255 goto done;
256 }
257 if (mtd_write_close(ctx) != 0) {
258 fprintf(stderr, "%s: failed to close \"%s\"", name, location);
259 result = strdup("");
260 goto done;
261 }
262 result = location;
Doug Zongker3d177d02010-07-01 09:18:44 -0700263#ifdef USE_EXT4
264 } else if (strcmp(fs_type, "ext4") == 0) {
Stephen Smalley779701d2012-02-09 14:13:23 -0500265 int status = make_ext4fs(location, atoll(fs_size), mount_point, sehandle);
Doug Zongker3d177d02010-07-01 09:18:44 -0700266 if (status != 0) {
267 fprintf(stderr, "%s: make_ext4fs failed (%d) on %s",
268 name, status, location);
269 result = strdup("");
270 goto done;
271 }
272 result = location;
273#endif
Doug Zongker9931f7f2009-06-10 14:11:53 -0700274 } else {
Doug Zongker3d177d02010-07-01 09:18:44 -0700275 fprintf(stderr, "%s: unsupported fs_type \"%s\" partition_type \"%s\"",
276 name, fs_type, partition_type);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700277 }
278
279done:
Doug Zongker3d177d02010-07-01 09:18:44 -0700280 free(fs_type);
281 free(partition_type);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700282 if (result != location) free(location);
Doug Zongker512536a2010-02-17 16:11:44 -0800283 return StringValue(result);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700284}
285
Doug Zongker8edb00c2009-06-11 17:21:44 -0700286
Doug Zongker512536a2010-02-17 16:11:44 -0800287Value* DeleteFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700288 char** paths = malloc(argc * sizeof(char*));
289 int i;
290 for (i = 0; i < argc; ++i) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700291 paths[i] = Evaluate(state, argv[i]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700292 if (paths[i] == NULL) {
293 int j;
294 for (j = 0; j < i; ++i) {
295 free(paths[j]);
296 }
297 free(paths);
298 return NULL;
299 }
300 }
301
302 bool recursive = (strcmp(name, "delete_recursive") == 0);
303
304 int success = 0;
305 for (i = 0; i < argc; ++i) {
306 if ((recursive ? dirUnlinkHierarchy(paths[i]) : unlink(paths[i])) == 0)
307 ++success;
308 free(paths[i]);
309 }
310 free(paths);
311
312 char buffer[10];
313 sprintf(buffer, "%d", success);
Doug Zongker512536a2010-02-17 16:11:44 -0800314 return StringValue(strdup(buffer));
Doug Zongker9931f7f2009-06-10 14:11:53 -0700315}
316
Doug Zongker8edb00c2009-06-11 17:21:44 -0700317
Doug Zongker512536a2010-02-17 16:11:44 -0800318Value* ShowProgressFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700319 if (argc != 2) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700320 return ErrorAbort(state, "%s() expects 2 args, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700321 }
322 char* frac_str;
323 char* sec_str;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700324 if (ReadArgs(state, argv, 2, &frac_str, &sec_str) < 0) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700325 return NULL;
326 }
327
328 double frac = strtod(frac_str, NULL);
329 int sec = strtol(sec_str, NULL, 10);
330
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700331 UpdaterInfo* ui = (UpdaterInfo*)(state->cookie);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700332 fprintf(ui->cmd_pipe, "progress %f %d\n", frac, sec);
333
Doug Zongker9931f7f2009-06-10 14:11:53 -0700334 free(sec_str);
Doug Zongker512536a2010-02-17 16:11:44 -0800335 return StringValue(frac_str);
Doug Zongkerfbf3c102009-06-24 09:36:20 -0700336}
337
Doug Zongker512536a2010-02-17 16:11:44 -0800338Value* SetProgressFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongkerfbf3c102009-06-24 09:36:20 -0700339 if (argc != 1) {
340 return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
341 }
342 char* frac_str;
343 if (ReadArgs(state, argv, 1, &frac_str) < 0) {
344 return NULL;
345 }
346
347 double frac = strtod(frac_str, NULL);
348
349 UpdaterInfo* ui = (UpdaterInfo*)(state->cookie);
350 fprintf(ui->cmd_pipe, "set_progress %f\n", frac);
351
Doug Zongker512536a2010-02-17 16:11:44 -0800352 return StringValue(frac_str);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700353}
354
Doug Zongker8edb00c2009-06-11 17:21:44 -0700355// package_extract_dir(package_path, destination_path)
Doug Zongker512536a2010-02-17 16:11:44 -0800356Value* PackageExtractDirFn(const char* name, State* state,
Doug Zongker8edb00c2009-06-11 17:21:44 -0700357 int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700358 if (argc != 2) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700359 return ErrorAbort(state, "%s() expects 2 args, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700360 }
361 char* zip_path;
362 char* dest_path;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700363 if (ReadArgs(state, argv, 2, &zip_path, &dest_path) < 0) return NULL;
Doug Zongker9931f7f2009-06-10 14:11:53 -0700364
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700365 ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip;
Doug Zongker9931f7f2009-06-10 14:11:53 -0700366
367 // To create a consistent system image, never use the clock for timestamps.
368 struct utimbuf timestamp = { 1217592000, 1217592000 }; // 8/1/2008 default
369
370 bool success = mzExtractRecursive(za, zip_path, dest_path,
371 MZ_EXTRACT_FILES_ONLY, &timestamp,
Stephen Smalley779701d2012-02-09 14:13:23 -0500372 NULL, NULL, sehandle);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700373 free(zip_path);
374 free(dest_path);
Doug Zongker512536a2010-02-17 16:11:44 -0800375 return StringValue(strdup(success ? "t" : ""));
Doug Zongker9931f7f2009-06-10 14:11:53 -0700376}
377
Doug Zongker8edb00c2009-06-11 17:21:44 -0700378
379// package_extract_file(package_path, destination_path)
Doug Zongker6aece332010-02-01 14:40:12 -0800380// or
381// package_extract_file(package_path)
382// to return the entire contents of the file as the result of this
Doug Zongker512536a2010-02-17 16:11:44 -0800383// function (the char* returned is actually a FileContents*).
384Value* PackageExtractFileFn(const char* name, State* state,
Doug Zongker8edb00c2009-06-11 17:21:44 -0700385 int argc, Expr* argv[]) {
Doug Zongker6aece332010-02-01 14:40:12 -0800386 if (argc != 1 && argc != 2) {
387 return ErrorAbort(state, "%s() expects 1 or 2 args, got %d",
388 name, argc);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700389 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700390 bool success = false;
Doug Zongker6aece332010-02-01 14:40:12 -0800391 if (argc == 2) {
392 // The two-argument version extracts to a file.
Doug Zongker8edb00c2009-06-11 17:21:44 -0700393
Doug Zongker6aece332010-02-01 14:40:12 -0800394 char* zip_path;
395 char* dest_path;
396 if (ReadArgs(state, argv, 2, &zip_path, &dest_path) < 0) return NULL;
397
398 ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip;
399 const ZipEntry* entry = mzFindZipEntry(za, zip_path);
400 if (entry == NULL) {
401 fprintf(stderr, "%s: no %s in package\n", name, zip_path);
402 goto done2;
403 }
404
405 FILE* f = fopen(dest_path, "wb");
406 if (f == NULL) {
407 fprintf(stderr, "%s: can't open %s for write: %s\n",
408 name, dest_path, strerror(errno));
409 goto done2;
410 }
411 success = mzExtractZipEntryToFile(za, entry, fileno(f));
412 fclose(f);
413
414 done2:
415 free(zip_path);
416 free(dest_path);
Doug Zongker512536a2010-02-17 16:11:44 -0800417 return StringValue(strdup(success ? "t" : ""));
Doug Zongker6aece332010-02-01 14:40:12 -0800418 } else {
419 // The one-argument version returns the contents of the file
420 // as the result.
421
422 char* zip_path;
Doug Zongker512536a2010-02-17 16:11:44 -0800423 Value* v = malloc(sizeof(Value));
424 v->type = VAL_BLOB;
425 v->size = -1;
426 v->data = NULL;
Doug Zongker6aece332010-02-01 14:40:12 -0800427
428 if (ReadArgs(state, argv, 1, &zip_path) < 0) return NULL;
429
430 ZipArchive* za = ((UpdaterInfo*)(state->cookie))->package_zip;
431 const ZipEntry* entry = mzFindZipEntry(za, zip_path);
432 if (entry == NULL) {
433 fprintf(stderr, "%s: no %s in package\n", name, zip_path);
434 goto done1;
435 }
436
Doug Zongker512536a2010-02-17 16:11:44 -0800437 v->size = mzGetZipEntryUncompLen(entry);
438 v->data = malloc(v->size);
439 if (v->data == NULL) {
Doug Zongker6aece332010-02-01 14:40:12 -0800440 fprintf(stderr, "%s: failed to allocate %ld bytes for %s\n",
Doug Zongker512536a2010-02-17 16:11:44 -0800441 name, (long)v->size, zip_path);
Doug Zongker6aece332010-02-01 14:40:12 -0800442 goto done1;
443 }
444
Doug Zongker512536a2010-02-17 16:11:44 -0800445 success = mzExtractZipEntryToBuffer(za, entry,
446 (unsigned char *)v->data);
Doug Zongker6aece332010-02-01 14:40:12 -0800447
448 done1:
449 free(zip_path);
450 if (!success) {
Doug Zongker512536a2010-02-17 16:11:44 -0800451 free(v->data);
452 v->data = NULL;
453 v->size = -1;
Doug Zongker6aece332010-02-01 14:40:12 -0800454 }
Doug Zongker512536a2010-02-17 16:11:44 -0800455 return v;
Doug Zongker8edb00c2009-06-11 17:21:44 -0700456 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700457}
458
Doug Zongkera23075f2012-08-06 16:19:09 -0700459// Create all parent directories of name, if necessary.
460static int make_parents(char* name) {
461 char* p;
462 for (p = name + (strlen(name)-1); p > name; --p) {
463 if (*p != '/') continue;
464 *p = '\0';
465 if (make_parents(name) < 0) return -1;
466 int result = mkdir(name, 0700);
467 if (result == 0) fprintf(stderr, "symlink(): created [%s]\n", name);
468 *p = '/';
469 if (result == 0 || errno == EEXIST) {
470 // successfully created or already existed; we're done
471 return 0;
472 } else {
473 fprintf(stderr, "failed to mkdir %s: %s\n", name, strerror(errno));
474 return -1;
475 }
476 }
477 return 0;
478}
Doug Zongker8edb00c2009-06-11 17:21:44 -0700479
Doug Zongker9931f7f2009-06-10 14:11:53 -0700480// symlink target src1 src2 ...
Doug Zongker60babf82009-09-18 15:11:24 -0700481// unlinks any previously existing src1, src2, etc before creating symlinks.
Doug Zongker512536a2010-02-17 16:11:44 -0800482Value* SymlinkFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700483 if (argc == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700484 return ErrorAbort(state, "%s() expects 1+ args, got %d", name, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700485 }
486 char* target;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700487 target = Evaluate(state, argv[0]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700488 if (target == NULL) return NULL;
489
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700490 char** srcs = ReadVarArgs(state, argc-1, argv+1);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700491 if (srcs == NULL) {
492 free(target);
493 return NULL;
494 }
495
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700496 int bad = 0;
Doug Zongker9931f7f2009-06-10 14:11:53 -0700497 int i;
498 for (i = 0; i < argc-1; ++i) {
Doug Zongker60babf82009-09-18 15:11:24 -0700499 if (unlink(srcs[i]) < 0) {
500 if (errno != ENOENT) {
501 fprintf(stderr, "%s: failed to remove %s: %s\n",
502 name, srcs[i], strerror(errno));
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700503 ++bad;
Doug Zongker60babf82009-09-18 15:11:24 -0700504 }
505 }
Doug Zongkera23075f2012-08-06 16:19:09 -0700506 if (make_parents(srcs[i])) {
507 fprintf(stderr, "%s: failed to symlink %s to %s: making parents failed\n",
508 name, srcs[i], target);
509 ++bad;
510 }
Doug Zongker60babf82009-09-18 15:11:24 -0700511 if (symlink(target, srcs[i]) < 0) {
512 fprintf(stderr, "%s: failed to symlink %s to %s: %s\n",
513 name, srcs[i], target, strerror(errno));
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700514 ++bad;
Doug Zongker60babf82009-09-18 15:11:24 -0700515 }
Doug Zongker9931f7f2009-06-10 14:11:53 -0700516 free(srcs[i]);
517 }
518 free(srcs);
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700519 if (bad) {
520 return ErrorAbort(state, "%s: some symlinks failed", name);
521 }
Doug Zongker512536a2010-02-17 16:11:44 -0800522 return StringValue(strdup(""));
Doug Zongker9931f7f2009-06-10 14:11:53 -0700523}
524
Doug Zongker8edb00c2009-06-11 17:21:44 -0700525
Doug Zongker512536a2010-02-17 16:11:44 -0800526Value* SetPermFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker9931f7f2009-06-10 14:11:53 -0700527 char* result = NULL;
528 bool recursive = (strcmp(name, "set_perm_recursive") == 0);
529
530 int min_args = 4 + (recursive ? 1 : 0);
531 if (argc < min_args) {
Doug Zongkera23075f2012-08-06 16:19:09 -0700532 return ErrorAbort(state, "%s() expects %d+ args, got %d",
533 name, min_args, argc);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700534 }
535
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700536 char** args = ReadVarArgs(state, argc, argv);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700537 if (args == NULL) return NULL;
538
539 char* end;
540 int i;
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700541 int bad = 0;
Doug Zongker9931f7f2009-06-10 14:11:53 -0700542
543 int uid = strtoul(args[0], &end, 0);
544 if (*end != '\0' || args[0][0] == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700545 ErrorAbort(state, "%s: \"%s\" not a valid uid", name, args[0]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700546 goto done;
547 }
548
549 int gid = strtoul(args[1], &end, 0);
550 if (*end != '\0' || args[1][0] == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700551 ErrorAbort(state, "%s: \"%s\" not a valid gid", name, args[1]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700552 goto done;
553 }
554
555 if (recursive) {
556 int dir_mode = strtoul(args[2], &end, 0);
557 if (*end != '\0' || args[2][0] == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700558 ErrorAbort(state, "%s: \"%s\" not a valid dirmode", name, args[2]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700559 goto done;
560 }
561
562 int file_mode = strtoul(args[3], &end, 0);
563 if (*end != '\0' || args[3][0] == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700564 ErrorAbort(state, "%s: \"%s\" not a valid filemode",
Doug Zongker9931f7f2009-06-10 14:11:53 -0700565 name, args[3]);
566 goto done;
567 }
568
569 for (i = 4; i < argc; ++i) {
570 dirSetHierarchyPermissions(args[i], uid, gid, dir_mode, file_mode);
571 }
572 } else {
573 int mode = strtoul(args[2], &end, 0);
574 if (*end != '\0' || args[2][0] == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700575 ErrorAbort(state, "%s: \"%s\" not a valid mode", name, args[2]);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700576 goto done;
577 }
578
Doug Zongker0bbfe3d2009-06-25 13:37:31 -0700579 for (i = 3; i < argc; ++i) {
Doug Zongker60babf82009-09-18 15:11:24 -0700580 if (chown(args[i], uid, gid) < 0) {
581 fprintf(stderr, "%s: chown of %s to %d %d failed: %s\n",
582 name, args[i], uid, gid, strerror(errno));
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700583 ++bad;
Doug Zongker60babf82009-09-18 15:11:24 -0700584 }
585 if (chmod(args[i], mode) < 0) {
586 fprintf(stderr, "%s: chmod of %s to %o failed: %s\n",
587 name, args[i], mode, strerror(errno));
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700588 ++bad;
Doug Zongker60babf82009-09-18 15:11:24 -0700589 }
Doug Zongker9931f7f2009-06-10 14:11:53 -0700590 }
591 }
592 result = strdup("");
593
594done:
595 for (i = 0; i < argc; ++i) {
596 free(args[i]);
597 }
598 free(args);
599
Doug Zongkeracd73ed2012-03-22 14:32:52 -0700600 if (bad) {
601 free(result);
602 return ErrorAbort(state, "%s: some changes failed", name);
603 }
Doug Zongker512536a2010-02-17 16:11:44 -0800604 return StringValue(result);
Doug Zongker9931f7f2009-06-10 14:11:53 -0700605}
606
Doug Zongker8edb00c2009-06-11 17:21:44 -0700607
Doug Zongker512536a2010-02-17 16:11:44 -0800608Value* GetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker8edb00c2009-06-11 17:21:44 -0700609 if (argc != 1) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700610 return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700611 }
612 char* key;
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700613 key = Evaluate(state, argv[0]);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700614 if (key == NULL) return NULL;
615
616 char value[PROPERTY_VALUE_MAX];
617 property_get(key, value, "");
618 free(key);
619
Doug Zongker512536a2010-02-17 16:11:44 -0800620 return StringValue(strdup(value));
Doug Zongker8edb00c2009-06-11 17:21:44 -0700621}
622
623
Doug Zongker47cace92009-06-18 10:11:50 -0700624// file_getprop(file, key)
625//
626// interprets 'file' as a getprop-style file (key=value pairs, one
627// per line, # comment lines and blank lines okay), and returns the value
628// for 'key' (or "" if it isn't defined).
Doug Zongker512536a2010-02-17 16:11:44 -0800629Value* FileGetPropFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker47cace92009-06-18 10:11:50 -0700630 char* result = NULL;
631 char* buffer = NULL;
632 char* filename;
633 char* key;
634 if (ReadArgs(state, argv, 2, &filename, &key) < 0) {
635 return NULL;
636 }
637
638 struct stat st;
639 if (stat(filename, &st) < 0) {
640 ErrorAbort(state, "%s: failed to stat \"%s\": %s",
641 name, filename, strerror(errno));
642 goto done;
643 }
644
645#define MAX_FILE_GETPROP_SIZE 65536
646
647 if (st.st_size > MAX_FILE_GETPROP_SIZE) {
648 ErrorAbort(state, "%s too large for %s (max %d)",
649 filename, name, MAX_FILE_GETPROP_SIZE);
650 goto done;
651 }
652
653 buffer = malloc(st.st_size+1);
654 if (buffer == NULL) {
Doug Zongkera23075f2012-08-06 16:19:09 -0700655 ErrorAbort(state, "%s: failed to alloc %lld bytes", name, st.st_size+1);
Doug Zongker47cace92009-06-18 10:11:50 -0700656 goto done;
657 }
658
659 FILE* f = fopen(filename, "rb");
660 if (f == NULL) {
661 ErrorAbort(state, "%s: failed to open %s: %s",
662 name, filename, strerror(errno));
663 goto done;
664 }
665
666 if (fread(buffer, 1, st.st_size, f) != st.st_size) {
Doug Zongkera23075f2012-08-06 16:19:09 -0700667 ErrorAbort(state, "%s: failed to read %lld bytes from %s",
Doug Zongker47cace92009-06-18 10:11:50 -0700668 name, st.st_size+1, filename);
669 fclose(f);
670 goto done;
671 }
672 buffer[st.st_size] = '\0';
673
674 fclose(f);
675
676 char* line = strtok(buffer, "\n");
677 do {
678 // skip whitespace at start of line
679 while (*line && isspace(*line)) ++line;
680
681 // comment or blank line: skip to next line
682 if (*line == '\0' || *line == '#') continue;
683
684 char* equal = strchr(line, '=');
685 if (equal == NULL) {
686 ErrorAbort(state, "%s: malformed line \"%s\": %s not a prop file?",
687 name, line, filename);
688 goto done;
689 }
690
691 // trim whitespace between key and '='
692 char* key_end = equal-1;
693 while (key_end > line && isspace(*key_end)) --key_end;
694 key_end[1] = '\0';
695
696 // not the key we're looking for
697 if (strcmp(key, line) != 0) continue;
698
699 // skip whitespace after the '=' to the start of the value
700 char* val_start = equal+1;
701 while(*val_start && isspace(*val_start)) ++val_start;
702
703 // trim trailing whitespace
704 char* val_end = val_start + strlen(val_start)-1;
705 while (val_end > val_start && isspace(*val_end)) --val_end;
706 val_end[1] = '\0';
707
708 result = strdup(val_start);
709 break;
710
711 } while ((line = strtok(NULL, "\n")));
712
713 if (result == NULL) result = strdup("");
714
715 done:
716 free(filename);
717 free(key);
718 free(buffer);
Doug Zongker512536a2010-02-17 16:11:44 -0800719 return StringValue(result);
Doug Zongker47cace92009-06-18 10:11:50 -0700720}
721
722
Doug Zongker8edb00c2009-06-11 17:21:44 -0700723static bool write_raw_image_cb(const unsigned char* data,
724 int data_len, void* ctx) {
725 int r = mtd_write_data((MtdWriteContext*)ctx, (const char *)data, data_len);
726 if (r == data_len) return true;
727 fprintf(stderr, "%s\n", strerror(errno));
728 return false;
729}
730
Doug Zongker179b2d92011-04-12 15:49:04 -0700731// write_raw_image(filename_or_blob, partition)
Doug Zongker512536a2010-02-17 16:11:44 -0800732Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongker8edb00c2009-06-11 17:21:44 -0700733 char* result = NULL;
734
Doug Zongker179b2d92011-04-12 15:49:04 -0700735 Value* partition_value;
736 Value* contents;
737 if (ReadValueArgs(state, argv, 2, &contents, &partition_value) < 0) {
Doug Zongker8edb00c2009-06-11 17:21:44 -0700738 return NULL;
739 }
740
Doug Zongkerdaefc1d2011-10-31 09:34:15 -0700741 char* partition = NULL;
Doug Zongker179b2d92011-04-12 15:49:04 -0700742 if (partition_value->type != VAL_STRING) {
743 ErrorAbort(state, "partition argument to %s must be string", name);
744 goto done;
745 }
Doug Zongkerdaefc1d2011-10-31 09:34:15 -0700746 partition = partition_value->data;
Doug Zongker8edb00c2009-06-11 17:21:44 -0700747 if (strlen(partition) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700748 ErrorAbort(state, "partition argument to %s can't be empty", name);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700749 goto done;
750 }
Doug Zongker179b2d92011-04-12 15:49:04 -0700751 if (contents->type == VAL_STRING && strlen((char*) contents->data) == 0) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700752 ErrorAbort(state, "file argument to %s can't be empty", name);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700753 goto done;
754 }
755
756 mtd_scan_partitions();
757 const MtdPartition* mtd = mtd_find_partition_by_name(partition);
758 if (mtd == NULL) {
759 fprintf(stderr, "%s: no mtd partition named \"%s\"\n", name, partition);
760 result = strdup("");
761 goto done;
762 }
763
764 MtdWriteContext* ctx = mtd_write_partition(mtd);
765 if (ctx == NULL) {
766 fprintf(stderr, "%s: can't write mtd partition \"%s\"\n",
767 name, partition);
768 result = strdup("");
769 goto done;
770 }
771
772 bool success;
773
Doug Zongker179b2d92011-04-12 15:49:04 -0700774 if (contents->type == VAL_STRING) {
775 // we're given a filename as the contents
776 char* filename = contents->data;
777 FILE* f = fopen(filename, "rb");
778 if (f == NULL) {
779 fprintf(stderr, "%s: can't open %s: %s\n",
780 name, filename, strerror(errno));
781 result = strdup("");
782 goto done;
Doug Zongker8edb00c2009-06-11 17:21:44 -0700783 }
Doug Zongker179b2d92011-04-12 15:49:04 -0700784
785 success = true;
786 char* buffer = malloc(BUFSIZ);
787 int read;
788 while (success && (read = fread(buffer, 1, BUFSIZ, f)) > 0) {
789 int wrote = mtd_write_data(ctx, buffer, read);
790 success = success && (wrote == read);
791 }
792 free(buffer);
793 fclose(f);
794 } else {
795 // we're given a blob as the contents
796 ssize_t wrote = mtd_write_data(ctx, contents->data, contents->size);
797 success = (wrote == contents->size);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700798 }
Doug Zongker179b2d92011-04-12 15:49:04 -0700799 if (!success) {
800 fprintf(stderr, "mtd_write_data to %s failed: %s\n",
801 partition, strerror(errno));
802 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700803
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700804 if (mtd_erase_blocks(ctx, -1) == -1) {
805 fprintf(stderr, "%s: error erasing blocks of %s\n", name, partition);
806 }
807 if (mtd_write_close(ctx) != 0) {
808 fprintf(stderr, "%s: error closing write of %s\n", name, partition);
809 }
810
Doug Zongker179b2d92011-04-12 15:49:04 -0700811 printf("%s %s partition\n",
812 success ? "wrote" : "failed to write", partition);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700813
814 result = success ? partition : strdup("");
815
816done:
Doug Zongker179b2d92011-04-12 15:49:04 -0700817 if (result != partition) FreeValue(partition_value);
818 FreeValue(contents);
Doug Zongker512536a2010-02-17 16:11:44 -0800819 return StringValue(result);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700820}
821
Doug Zongker8edb00c2009-06-11 17:21:44 -0700822// apply_patch_space(bytes)
Doug Zongkerc4351c72010-02-22 14:46:32 -0800823Value* ApplyPatchSpaceFn(const char* name, State* state,
824 int argc, Expr* argv[]) {
825 char* bytes_str;
826 if (ReadArgs(state, argv, 1, &bytes_str) < 0) {
827 return NULL;
828 }
829
830 char* endptr;
831 size_t bytes = strtol(bytes_str, &endptr, 10);
832 if (bytes == 0 && endptr == bytes_str) {
833 ErrorAbort(state, "%s(): can't parse \"%s\" as byte count\n\n",
834 name, bytes_str);
835 free(bytes_str);
836 return NULL;
837 }
838
839 return StringValue(strdup(CacheSizeCheck(bytes) ? "" : "t"));
840}
841
842
843// apply_patch(srcfile, tgtfile, tgtsha1, tgtsize, sha1_1, patch_1, ...)
Doug Zongker512536a2010-02-17 16:11:44 -0800844Value* ApplyPatchFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongkerc4351c72010-02-22 14:46:32 -0800845 if (argc < 6 || (argc % 2) == 1) {
846 return ErrorAbort(state, "%s(): expected at least 6 args and an "
847 "even number, got %d",
848 name, argc);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700849 }
850
Doug Zongkerc4351c72010-02-22 14:46:32 -0800851 char* source_filename;
852 char* target_filename;
853 char* target_sha1;
854 char* target_size_str;
855 if (ReadArgs(state, argv, 4, &source_filename, &target_filename,
856 &target_sha1, &target_size_str) < 0) {
857 return NULL;
Doug Zongker8edb00c2009-06-11 17:21:44 -0700858 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700859
Doug Zongkerc4351c72010-02-22 14:46:32 -0800860 char* endptr;
861 size_t target_size = strtol(target_size_str, &endptr, 10);
862 if (target_size == 0 && endptr == target_size_str) {
863 ErrorAbort(state, "%s(): can't parse \"%s\" as byte count",
864 name, target_size_str);
865 free(source_filename);
866 free(target_filename);
867 free(target_sha1);
868 free(target_size_str);
869 return NULL;
870 }
871
872 int patchcount = (argc-4) / 2;
873 Value** patches = ReadValueVarArgs(state, argc-4, argv+4);
Doug Zongker8edb00c2009-06-11 17:21:44 -0700874
875 int i;
Doug Zongkerc4351c72010-02-22 14:46:32 -0800876 for (i = 0; i < patchcount; ++i) {
877 if (patches[i*2]->type != VAL_STRING) {
878 ErrorAbort(state, "%s(): sha-1 #%d is not string", name, i);
879 break;
880 }
881 if (patches[i*2+1]->type != VAL_BLOB) {
882 ErrorAbort(state, "%s(): patch #%d is not blob", name, i);
883 break;
884 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700885 }
Doug Zongkerc4351c72010-02-22 14:46:32 -0800886 if (i != patchcount) {
887 for (i = 0; i < patchcount*2; ++i) {
888 FreeValue(patches[i]);
889 }
890 free(patches);
891 return NULL;
892 }
Doug Zongker8edb00c2009-06-11 17:21:44 -0700893
Doug Zongkerc4351c72010-02-22 14:46:32 -0800894 char** patch_sha_str = malloc(patchcount * sizeof(char*));
895 for (i = 0; i < patchcount; ++i) {
896 patch_sha_str[i] = patches[i*2]->data;
897 patches[i*2]->data = NULL;
898 FreeValue(patches[i*2]);
899 patches[i] = patches[i*2+1];
Doug Zongker8edb00c2009-06-11 17:21:44 -0700900 }
Doug Zongkerc4351c72010-02-22 14:46:32 -0800901
902 int result = applypatch(source_filename, target_filename,
903 target_sha1, target_size,
Doug Zongkera3ccba62012-08-20 15:28:02 -0700904 patchcount, patch_sha_str, patches, NULL);
Doug Zongkerc4351c72010-02-22 14:46:32 -0800905
906 for (i = 0; i < patchcount; ++i) {
907 FreeValue(patches[i]);
908 }
909 free(patch_sha_str);
910 free(patches);
911
912 return StringValue(strdup(result == 0 ? "t" : ""));
913}
914
915// apply_patch_check(file, [sha1_1, ...])
916Value* ApplyPatchCheckFn(const char* name, State* state,
917 int argc, Expr* argv[]) {
918 if (argc < 1) {
919 return ErrorAbort(state, "%s(): expected at least 1 arg, got %d",
920 name, argc);
921 }
922
923 char* filename;
924 if (ReadArgs(state, argv, 1, &filename) < 0) {
925 return NULL;
926 }
927
928 int patchcount = argc-1;
929 char** sha1s = ReadVarArgs(state, argc-1, argv+1);
930
931 int result = applypatch_check(filename, patchcount, sha1s);
932
933 int i;
934 for (i = 0; i < patchcount; ++i) {
935 free(sha1s[i]);
936 }
937 free(sha1s);
938
939 return StringValue(strdup(result == 0 ? "t" : ""));
Doug Zongker8edb00c2009-06-11 17:21:44 -0700940}
941
Doug Zongker512536a2010-02-17 16:11:44 -0800942Value* UIPrintFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700943 char** args = ReadVarArgs(state, argc, argv);
944 if (args == NULL) {
945 return NULL;
946 }
947
948 int size = 0;
949 int i;
950 for (i = 0; i < argc; ++i) {
951 size += strlen(args[i]);
952 }
953 char* buffer = malloc(size+1);
954 size = 0;
955 for (i = 0; i < argc; ++i) {
956 strcpy(buffer+size, args[i]);
957 size += strlen(args[i]);
958 free(args[i]);
959 }
960 free(args);
961 buffer[size] = '\0';
962
963 char* line = strtok(buffer, "\n");
964 while (line) {
965 fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe,
966 "ui_print %s\n", line);
967 line = strtok(NULL, "\n");
968 }
969 fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe, "ui_print\n");
970
Doug Zongker512536a2010-02-17 16:11:44 -0800971 return StringValue(buffer);
Doug Zongkerd9c9d102009-06-12 12:24:39 -0700972}
973
Doug Zongkerd0181b82011-10-19 10:51:12 -0700974Value* WipeCacheFn(const char* name, State* state, int argc, Expr* argv[]) {
975 if (argc != 0) {
976 return ErrorAbort(state, "%s() expects no args, got %d", name, argc);
977 }
978 fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe, "wipe_cache\n");
979 return StringValue(strdup("t"));
980}
981
Doug Zongker512536a2010-02-17 16:11:44 -0800982Value* RunProgramFn(const char* name, State* state, int argc, Expr* argv[]) {
Doug Zongkera3f89ea2009-09-10 14:10:48 -0700983 if (argc < 1) {
984 return ErrorAbort(state, "%s() expects at least 1 arg", name);
985 }
986 char** args = ReadVarArgs(state, argc, argv);
987 if (args == NULL) {
988 return NULL;
989 }
990
991 char** args2 = malloc(sizeof(char*) * (argc+1));
992 memcpy(args2, args, sizeof(char*) * argc);
993 args2[argc] = NULL;
994
995 fprintf(stderr, "about to run program [%s] with %d args\n", args2[0], argc);
996
997 pid_t child = fork();
998 if (child == 0) {
999 execv(args2[0], args2);
1000 fprintf(stderr, "run_program: execv failed: %s\n", strerror(errno));
1001 _exit(1);
1002 }
1003 int status;
1004 waitpid(child, &status, 0);
1005 if (WIFEXITED(status)) {
1006 if (WEXITSTATUS(status) != 0) {
1007 fprintf(stderr, "run_program: child exited with status %d\n",
1008 WEXITSTATUS(status));
1009 }
1010 } else if (WIFSIGNALED(status)) {
1011 fprintf(stderr, "run_program: child terminated by signal %d\n",
1012 WTERMSIG(status));
1013 }
1014
1015 int i;
1016 for (i = 0; i < argc; ++i) {
1017 free(args[i]);
1018 }
1019 free(args);
1020 free(args2);
1021
1022 char buffer[20];
1023 sprintf(buffer, "%d", status);
1024
Doug Zongker512536a2010-02-17 16:11:44 -08001025 return StringValue(strdup(buffer));
Doug Zongkera3f89ea2009-09-10 14:10:48 -07001026}
1027
Doug Zongker512536a2010-02-17 16:11:44 -08001028// Take a sha-1 digest and return it as a newly-allocated hex string.
1029static char* PrintSha1(uint8_t* digest) {
1030 char* buffer = malloc(SHA_DIGEST_SIZE*2 + 1);
1031 int i;
1032 const char* alphabet = "0123456789abcdef";
1033 for (i = 0; i < SHA_DIGEST_SIZE; ++i) {
1034 buffer[i*2] = alphabet[(digest[i] >> 4) & 0xf];
1035 buffer[i*2+1] = alphabet[digest[i] & 0xf];
1036 }
1037 buffer[i*2] = '\0';
1038 return buffer;
1039}
1040
1041// sha1_check(data)
1042// to return the sha1 of the data (given in the format returned by
1043// read_file).
1044//
1045// sha1_check(data, sha1_hex, [sha1_hex, ...])
1046// returns the sha1 of the file if it matches any of the hex
1047// strings passed, or "" if it does not equal any of them.
1048//
1049Value* Sha1CheckFn(const char* name, State* state, int argc, Expr* argv[]) {
1050 if (argc < 1) {
1051 return ErrorAbort(state, "%s() expects at least 1 arg", name);
1052 }
1053
1054 Value** args = ReadValueVarArgs(state, argc, argv);
1055 if (args == NULL) {
1056 return NULL;
1057 }
1058
1059 if (args[0]->size < 0) {
1060 fprintf(stderr, "%s(): no file contents received", name);
1061 return StringValue(strdup(""));
1062 }
1063 uint8_t digest[SHA_DIGEST_SIZE];
1064 SHA(args[0]->data, args[0]->size, digest);
1065 FreeValue(args[0]);
1066
1067 if (argc == 1) {
1068 return StringValue(PrintSha1(digest));
1069 }
1070
1071 int i;
1072 uint8_t* arg_digest = malloc(SHA_DIGEST_SIZE);
1073 for (i = 1; i < argc; ++i) {
1074 if (args[i]->type != VAL_STRING) {
1075 fprintf(stderr, "%s(): arg %d is not a string; skipping",
1076 name, i);
1077 } else if (ParseSha1(args[i]->data, arg_digest) != 0) {
1078 // Warn about bad args and skip them.
1079 fprintf(stderr, "%s(): error parsing \"%s\" as sha-1; skipping",
1080 name, args[i]->data);
1081 } else if (memcmp(digest, arg_digest, SHA_DIGEST_SIZE) == 0) {
1082 break;
1083 }
1084 FreeValue(args[i]);
1085 }
1086 if (i >= argc) {
1087 // Didn't match any of the hex strings; return false.
1088 return StringValue(strdup(""));
1089 }
1090 // Found a match; free all the remaining arguments and return the
1091 // matched one.
1092 int j;
1093 for (j = i+1; j < argc; ++j) {
1094 FreeValue(args[j]);
1095 }
1096 return args[i];
1097}
1098
Hristo Bojinovdb314d62010-08-02 10:29:49 -07001099// Read a local file and return its contents (the Value* returned
Doug Zongker512536a2010-02-17 16:11:44 -08001100// is actually a FileContents*).
1101Value* ReadFileFn(const char* name, State* state, int argc, Expr* argv[]) {
1102 if (argc != 1) {
1103 return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);
1104 }
1105 char* filename;
1106 if (ReadArgs(state, argv, 1, &filename) < 0) return NULL;
1107
1108 Value* v = malloc(sizeof(Value));
1109 v->type = VAL_BLOB;
1110
1111 FileContents fc;
Hristo Bojinovdb314d62010-08-02 10:29:49 -07001112 if (LoadFileContents(filename, &fc, RETOUCH_DONT_MASK) != 0) {
Doug Zongker512536a2010-02-17 16:11:44 -08001113 ErrorAbort(state, "%s() loading \"%s\" failed: %s",
1114 name, filename, strerror(errno));
1115 free(filename);
1116 free(v);
1117 free(fc.data);
1118 return NULL;
1119 }
1120
1121 v->size = fc.size;
1122 v->data = (char*)fc.data;
1123
1124 free(filename);
1125 return v;
1126}
Doug Zongker8edb00c2009-06-11 17:21:44 -07001127
Doug Zongker9931f7f2009-06-10 14:11:53 -07001128void RegisterInstallFunctions() {
1129 RegisterFunction("mount", MountFn);
Doug Zongker8edb00c2009-06-11 17:21:44 -07001130 RegisterFunction("is_mounted", IsMountedFn);
Doug Zongker9931f7f2009-06-10 14:11:53 -07001131 RegisterFunction("unmount", UnmountFn);
1132 RegisterFunction("format", FormatFn);
1133 RegisterFunction("show_progress", ShowProgressFn);
Doug Zongkerfbf3c102009-06-24 09:36:20 -07001134 RegisterFunction("set_progress", SetProgressFn);
Doug Zongker9931f7f2009-06-10 14:11:53 -07001135 RegisterFunction("delete", DeleteFn);
1136 RegisterFunction("delete_recursive", DeleteFn);
Doug Zongker8edb00c2009-06-11 17:21:44 -07001137 RegisterFunction("package_extract_dir", PackageExtractDirFn);
1138 RegisterFunction("package_extract_file", PackageExtractFileFn);
Doug Zongker9931f7f2009-06-10 14:11:53 -07001139 RegisterFunction("symlink", SymlinkFn);
1140 RegisterFunction("set_perm", SetPermFn);
1141 RegisterFunction("set_perm_recursive", SetPermFn);
Doug Zongker8edb00c2009-06-11 17:21:44 -07001142
1143 RegisterFunction("getprop", GetPropFn);
Doug Zongker47cace92009-06-18 10:11:50 -07001144 RegisterFunction("file_getprop", FileGetPropFn);
Doug Zongker8edb00c2009-06-11 17:21:44 -07001145 RegisterFunction("write_raw_image", WriteRawImageFn);
Doug Zongker8edb00c2009-06-11 17:21:44 -07001146
1147 RegisterFunction("apply_patch", ApplyPatchFn);
Doug Zongkerc4351c72010-02-22 14:46:32 -08001148 RegisterFunction("apply_patch_check", ApplyPatchCheckFn);
1149 RegisterFunction("apply_patch_space", ApplyPatchSpaceFn);
Doug Zongkerd9c9d102009-06-12 12:24:39 -07001150
Doug Zongker512536a2010-02-17 16:11:44 -08001151 RegisterFunction("read_file", ReadFileFn);
1152 RegisterFunction("sha1_check", Sha1CheckFn);
1153
Doug Zongkerd0181b82011-10-19 10:51:12 -07001154 RegisterFunction("wipe_cache", WipeCacheFn);
1155
Doug Zongkerd9c9d102009-06-12 12:24:39 -07001156 RegisterFunction("ui_print", UIPrintFn);
Doug Zongkera3f89ea2009-09-10 14:10:48 -07001157
1158 RegisterFunction("run_program", RunProgramFn);
Doug Zongker9931f7f2009-06-10 14:11:53 -07001159}