TheArchive/Magisk
1
0
Fork 0
mirror of https://github.com/topjohnwu/Magisk.git synced 2024-12-24 17:47:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Generalize cpio functions

Browse Source
This commit is contained in:
topjohnwu 2017-12-04 03:14:04 +08:00
parent 32c8e7522f
commit 2e25431bb6
5 changed files with 103 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
jni/include/cpio.h
View File

@ -17,7 +17,7 @@ typedef struct cpio_entry {
// uint32_t devminor;
// uint32_t rdevmajor;
// uint32_t rdevminor;
uint32_t namesize;
// uint32_t namesize;
// uint32_t check;
char *filename;
char *data;
@ -41,17 +41,20 @@ typedef struct cpio_newc_header {
char check[8];
} cpio_newc_header;
void parse_cpio(const char *filename, struct vector *v);
void dump_cpio(const char *filename, struct vector *v);
// Basic cpio functions
void parse_cpio(struct vector *v, const char *filename);
void dump_cpio(struct vector *v, const char *filename);
void cpio_vec_destroy(struct vector *v);
void cpio_rm(int recursive, const char *entry, struct vector *v);
void cpio_mkdir(mode_t mode, const char *entry, struct vector *v);
void cpio_add(mode_t mode, const char *entry, const char *filename, struct vector *v);
void cpio_mv(struct vector *v, const char *from, const char *to);
void cpio_test(struct vector *v);
void cpio_extract(const char *entry, const char *filename, struct vector *v);
void cpio_backup(const char *orig, const char *sha1, struct vector *v);
void cpio_rm(struct vector *v, int recursive, const char *entry);
void cpio_mkdir(struct vector *v, mode_t mode, const char *entry);
void cpio_add(struct vector *v, mode_t mode, const char *entry, const char *filename);
int cpio_mv(struct vector *v, const char *from, const char *to);
int cpio_extract(struct vector *v, const char *entry, const char *filename);
// Magisk specific
int cpio_test(struct vector *v);
void cpio_backup(struct vector *v, const char *orig, const char *sha1);
int cpio_restore(struct vector *v);
void cpio_stocksha1(struct vector *v);
char *cpio_stocksha1(struct vector *v);
#endif

14
jni/magiskboot/magiskboot.h
View File

@ -32,18 +32,4 @@ size_t lz4_legacy(int mode, int fd, const void *buf, size_t size);
long long comp(file_t type, int to, const void *from, size_t size);
long long decomp(file_t type, int to, const void *from, size_t size);
typedef enum {
NONE,
RM,
MKDIR,
ADD,
MV,
EXTRACT,
TEST,
PATCH,
BACKUP,
RESTORE,
STOCKSHA1
} command_t;
#endif

1
jni/magiskboot/main.c
View File

@ -96,6 +96,7 @@ static void usage(char *arg0) {
int main(int argc, char *argv[]) {
fprintf(stderr, "MagiskBoot v" xstr(MAGISK_VERSION) "(" xstr(MAGISK_VER_CODE) ") (by topjohnwu) - Boot Image Modification Tool\n\n");
umask(0);
if (argc > 1 && strcmp(argv[1], "--cleanup") == 0) {
fprintf(stderr, "Cleaning up...\n\n");
char name[PATH_MAX];

75
jni/magiskboot/ramdisk.c
View File

@ -71,76 +71,47 @@ void cpio_patch(struct vector *v, int keepverity, int keepforceencrypt) {
}
int cpio_commands(const char *command, int argc, char *argv[]) {
int recursive = 0, ret = 0;
command_t cmd;
int ret = 0;
char *incpio = argv[0];
++argv;
--argc;
struct vector v;
vec_init(&v);
parse_cpio(&v, incpio);
if (strcmp(command, "test") == 0) {
cmd = TEST;
return cpio_test(&v);
} else if (strcmp(command, "restore") == 0) {
cmd = RESTORE;
ret = cpio_restore(&v);
} else if (strcmp(command, "stocksha1") == 0) {
cmd = STOCKSHA1;
printf("%s\n", cpio_stocksha1(&v));
return 0;
} else if (argc >= 1 && strcmp(command, "backup") == 0) {
cmd = BACKUP;
cpio_backup(&v, argv[0], argc > 1 ? argv[1] : NULL);
} else if (argc > 0 && strcmp(command, "rm") == 0) {
cmd = RM;
int recursive = 0;
if (argc == 2 && strcmp(argv[0], "-r") == 0) {
recursive = 1;
++argv;
--argc;
}
cpio_rm(&v, recursive, argv[0]);
} else if (argc == 2 && strcmp(command, "mv") == 0) {
cmd = MV;
if (cpio_mv(&v, argv[0], argv[1]))
return 1;
} else if (argc == 2 && strcmp(command, "patch") == 0) {
cmd = PATCH;
} else if (argc == 2 && strcmp(command, "extract") == 0) {
cmd = EXTRACT;
} else if (argc == 2 && strcmp(command, "mkdir") == 0) {
cmd = MKDIR;
} else if (argc == 3 && strcmp(command, "add") == 0) {
cmd = ADD;
} else {
cmd = NONE;
}
struct vector v;
vec_init(&v);
parse_cpio(incpio, &v);
switch(cmd) {
case TEST:
cpio_test(&v);
break;
case RESTORE:
ret = cpio_restore(&v);
break;
case STOCKSHA1:
cpio_stocksha1(&v);
return 0;
case BACKUP:
cpio_backup(argv[0], argc > 1 ? argv[1] : NULL, &v);
case RM:
cpio_rm(recursive, argv[0], &v);
break;
case PATCH:
cpio_patch(&v, strcmp(argv[0], "true") == 0, strcmp(argv[1], "true") == 0);
break;
case EXTRACT:
cpio_extract(argv[0], argv[1], &v);
break;
case MKDIR:
cpio_mkdir(strtoul(argv[0], NULL, 8), argv[1], &v);
break;
case ADD:
cpio_add(strtoul(argv[0], NULL, 8), argv[1], argv[2], &v);
break;
case MV:
cpio_mv(&v, argv[0], argv[1]);
break;
case NONE:
} else if (argc == 2 && strcmp(command, "extract") == 0) {
return cpio_extract(&v, argv[0], argv[1]);
} else if (argc == 2 && strcmp(command, "mkdir") == 0) {
cpio_mkdir(&v, strtoul(argv[0], NULL, 8), argv[1]);
} else if (argc == 3 && strcmp(command, "add") == 0) {
cpio_add(&v, strtoul(argv[0], NULL, 8), argv[1], argv[2]);
} else {
return 1;
}
dump_cpio(incpio, &v);
dump_cpio(&v, incpio);
cpio_vec_destroy(&v);
exit(ret);
}

135
jni/utils/cpio.c
View File

@ -48,9 +48,10 @@ static int cpio_cmp(const void *a, const void *b) {
}
// Parse cpio file to a vector of cpio_entry
void parse_cpio(const char *filename, struct vector *v) {
void parse_cpio(struct vector *v, const char *filename) {
fprintf(stderr, "Loading cpio: [%s]\n\n", filename);
int fd = xopen(filename, O_RDONLY);
int fd = open(filename, O_RDONLY);
if (fd < 0) return;
cpio_newc_header header;
cpio_entry *f;
while(xxread(fd, &header, 110) != -1) {
@ -66,10 +67,10 @@ void parse_cpio(const char *filename, struct vector *v) {
// f->devminor = x8u(header.devminor);
// f->rdevmajor = x8u(header.rdevmajor);
// f->rdevminor = x8u(header.rdevminor);
f->namesize = x8u(header.namesize);
uint32_t namesize = x8u(header.namesize);
// f->check = x8u(header.check);
f->filename = xmalloc(f->namesize);
xxread(fd, f->filename, f->namesize);
f->filename = xmalloc(namesize);
xxread(fd, f->filename, namesize);
file_align(fd, 4, 0);
if (strcmp(f->filename, ".") == 0 || strcmp(f->filename, "..") == 0) {
cpio_free(f);
@ -80,7 +81,7 @@ void parse_cpio(const char *filename, struct vector *v) {
break;
}
if (f->filesize) {
f->data = malloc(f->filesize);
f->data = xmalloc(f->filesize);
xxread(fd, f->data, f->filesize);
file_align(fd, 4, 0);
}
@ -89,7 +90,7 @@ void parse_cpio(const char *filename, struct vector *v) {
close(fd);
}
void dump_cpio(const char *filename, struct vector *v) {
void dump_cpio(struct vector *v, const char *filename) {
fprintf(stderr, "\nDump cpio: [%s]\n\n", filename);
int fd = creat(filename, 0644);
unsigned inode = 300000;
@ -111,11 +112,11 @@ void dump_cpio(const char *filename, struct vector *v) {
0, // f->devminor
0, // f->rdevmajor
0, // f->rdevminor
f->namesize,
(uint32_t) strlen(f->filename) + 1,
0 // f->check
);
xwrite(fd, header, 110);
xwrite(fd, f->filename, f->namesize);
xwrite(fd, f->filename, strlen(f->filename) + 1);
file_align(fd, 4, 1);
if (f->filesize) {
xwrite(fd, f->data, f->filesize);
@ -139,7 +140,7 @@ void cpio_vec_destroy(struct vector *v) {
vec_destroy(v);
}
void cpio_rm(int recursive, const char *entry, struct vector *v) {
void cpio_rm(struct vector *v, int recursive, const char *entry) {
cpio_entry *f;
vec_for_each(v, f) {
if (strncmp(f->filename, entry, strlen(entry)) == 0) {
@ -155,20 +156,18 @@ void cpio_rm(int recursive, const char *entry, struct vector *v) {
}
}
void cpio_mkdir(mode_t mode, const char *entry, struct vector *v) {
void cpio_mkdir(struct vector *v, mode_t mode, const char *entry) {
cpio_entry *f = xcalloc(sizeof(*f), 1);
f->mode = S_IFDIR | mode;
f->namesize = strlen(entry) + 1;
f->filename = strdup(entry);
cpio_vec_insert(v, f);
fprintf(stderr, "Create directory [%s] (%04o)\n",entry, mode);
}
void cpio_add(mode_t mode, const char *entry, const char *filename, struct vector *v) {
void cpio_add(struct vector *v, mode_t mode, const char *entry, const char *filename) {
int fd = xopen(filename, O_RDONLY);
cpio_entry *f = xcalloc(sizeof(*f), 1);
f->mode = S_IFREG | mode;
f->namesize = strlen(entry) + 1;
f->filename = strdup(entry);
f->filesize = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);
@ -179,7 +178,7 @@ void cpio_add(mode_t mode, const char *entry, const char *filename, struct vecto
fprintf(stderr, "Add entry [%s] (%04o)\n", entry, mode);
}
void cpio_mv(struct vector *v, const char *from, const char *to) {
int cpio_mv(struct vector *v, const char *from, const char *to) {
struct cpio_entry *f, *t;
vec_for_each(v, f) {
if (strcmp(f->filename, from) == 0) {
@ -191,16 +190,36 @@ void cpio_mv(struct vector *v, const char *from, const char *to) {
}
}
free(f->filename);
f->namesize = strlen(to) + 1;
f->filename = strdup(to);
return;
return 0;
}
}
fprintf(stderr, "Cannot find entry %s\n", from);
exit(1);
return 1;
}
void cpio_test(struct vector *v) {
int cpio_extract(struct vector *v, const char *entry, const char *filename) {
cpio_entry *f;
vec_for_each(v, f) {
if (strcmp(f->filename, entry) == 0) {
fprintf(stderr, "Extracting [%s] to [%s]\n\n", entry, filename);
unlink(filename);
if (S_ISREG(f->mode)) {
int fd = creat(filename, f->mode & 0777);
xwrite(fd, f->data, f->filesize);
fchown(fd, f->uid, f->gid);
close(fd);
} else if (S_ISLNK(f->mode)) {
symlink(f->data, filename);
}
return 0;
}
}
fprintf(stderr, "Cannot find the file entry [%s]\n", entry);
return 1;
}
int cpio_test(struct vector *v) {
#define STOCK_BOOT 0x0
#define MAGISK_PATCH 0x1
#define OTHER_PATCH 0x2
@ -222,74 +241,52 @@ void cpio_test(struct vector *v) {
}
}
cpio_vec_destroy(v);
exit(ret);
return ret;
}
void cpio_extract(const char *entry, const char *filename, struct vector *v) {
cpio_entry *f;
vec_for_each(v, f) {
if (strcmp(f->filename, entry) == 0 && S_ISREG(f->mode)) {
fprintf(stderr, "Extracting [%s] to [%s]\n\n", entry, filename);
int fd = creat(filename, 0644);
xwrite(fd, f->data, f->filesize);
fchmod(fd, f->mode);
fchown(fd, f->uid, f->gid);
close(fd);
exit(0);
}
}
LOGE("Cannot find the file entry [%s]\n", entry);
}
void cpio_backup(const char *orig, const char *sha1, struct vector *v) {
void cpio_backup(struct vector *v, const char *orig, const char *sha1) {
struct vector o_body, *o = &o_body, bak;
cpio_entry *m, *n, *rem, *cksm;
char buf[PATH_MAX];
int res, doBak;
if (sha1) cksm = xcalloc(sizeof(*cksm), 1);
vec_init(o);
vec_init(&bak);
m = xcalloc(sizeof(*m), 1);
m->filename = strdup(".backup");
m->namesize = strlen(m->filename) + 1;
m->mode = S_IFDIR;
vec_push_back(&bak, m);
m = xcalloc(sizeof(*m), 1);
m->filename = strdup(".backup/.magisk");
m->namesize = strlen(m->filename) + 1;
m->mode = S_IFREG;
vec_push_back(&bak, m);
rem = xcalloc(sizeof(*rem), 1);
rem->filename = strdup(".backup/.rmlist");
rem->namesize = strlen(rem->filename) + 1;
rem->mode = S_IFREG;
vec_push_back(&bak, rem);
if (sha1) vec_push_back(&bak, cksm);
parse_cpio(orig, o);
// Remove possible backups in original ramdisk
cpio_rm(1, ".backup", o);
cpio_rm(1, ".backup", v);
// Sort both vectors before comparing
vec_sort(v, cpio_cmp);
vec_sort(o, cpio_cmp);
if (sha1) {
fprintf(stderr, "Save SHA1: [%s] -> [.backup/.sha1]\n", sha1);
cksm = xcalloc(sizeof(*cksm), 1);
vec_push_back(&bak, cksm);
cksm->filename = strdup(".backup/.sha1");
cksm->namesize = strlen(cksm->filename) + 1;
cksm->mode = S_IFREG;
cksm->data = strdup(sha1);
cksm->filesize = strlen(sha1) + 1;
}
parse_cpio(o, orig);
// Remove possible backups in original ramdisk
cpio_rm(o, 1, ".backup");
cpio_rm(v, 1, ".backup");
// Sort both vectors before comparing
vec_sort(v, cpio_cmp);
vec_sort(o, cpio_cmp);
// Start comparing
size_t i = 0, j = 0;
while(i != vec_size(o) || j != vec_size(v)) {
@ -322,16 +319,15 @@ void cpio_backup(const char *orig, const char *sha1, struct vector *v) {
// Someting new in ramdisk, record in rem
++j;
if (n->remove) continue;
rem->data = xrealloc(rem->data, rem->filesize + n->namesize);
memcpy(rem->data + rem->filesize, n->filename, n->namesize);
rem->filesize += n->namesize;
rem->data = xrealloc(rem->data, rem->filesize + strlen(n->filename) + 1);
memcpy(rem->data + rem->filesize, n->filename, strlen(n->filename) + 1);
rem->filesize += strlen(n->filename) + 1;
fprintf(stderr, "Record new entry: [%s] -> [.backup/.rmlist]\n", n->filename);
}
if (doBak) {
m->namesize += 8;
m->filename = realloc(m->filename, m->namesize);
strcpy(buf, m->filename);
sprintf(m->filename, ".backup/%s", buf);
sprintf(buf, ".backup/%s", m->filename);
free(m->filename);
m->filename = strdup(buf);
fprintf(stderr, "[%s] -> [%s]\n", buf, m->filename);
vec_push_back(&bak, m);
// NULL the original entry, so it won't be freed
@ -362,13 +358,12 @@ int cpio_restore(struct vector *v) {
if (f->filename[8] == '.') {
if (strcmp(f->filename, ".backup/.rmlist") == 0) {
for (int pos = 0; pos < f->filesize; pos += strlen(f->data + pos) + 1)
cpio_rm(0, f->data + pos, v);
cpio_rm(v, 0, f->data + pos);
}
continue;
} else {
n = xcalloc(sizeof(*n), 1);
memcpy(n, f, sizeof(*f));
n->namesize -= 8;
n->filename = strdup(f->filename + 8);
n->data = f->data;
f->data = NULL;
@ -379,13 +374,13 @@ int cpio_restore(struct vector *v) {
}
}
// Some known stuff we can remove
cpio_rm(0, "sbin/magic_mask.sh", v);
cpio_rm(0, "init.magisk.rc", v);
cpio_rm(0, "magisk", v);
cpio_rm(v, 0, "sbin/magic_mask.sh");
cpio_rm(v, 0, "init.magisk.rc");
cpio_rm(v, 0, "magisk");
return ret;
}
void cpio_stocksha1(struct vector *v) {
char *cpio_stocksha1(struct vector *v) {
cpio_entry *f;
char sha1[41];
vec_for_each(v, f) {
@ -396,12 +391,12 @@ void cpio_stocksha1(struct vector *v) {
pos += 12;
memcpy(sha1, pos, 40);
sha1[40] = '\0';
printf("%s\n", sha1);
return;
return strdup(sha1);
}
}
} else if (strcmp(f->filename, ".backup/.sha1") == 0) {
printf("%s\n", f->data);
return f->data;
}
}
return NULL;
}