YZBruh/pmt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pmt: initial 2.0.0 update

Browse Source
This commit is contained in:
Yağız Zengin
2024-05-26 10:49:33 +03:00
parent f771fb7c68
commit f5531fde32
30 changed files with 380 additions and 730 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
jni/Android.mk Executable file
View File

@@ -0,0 +1,48 @@
# By YZBruh
# Copyright 2024 Partition Manager
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH := $(call my-dir)
ENVCONF := $(LOCAL_PATH)/config/env.mk
include $(CLEAR_VARS)
include $(ENVCONF)
# configration
LOCAL_MODULE = pmt
LOCAL_SRC_FILES = \
pmt.c \
versioner.c \
tools.c \
checkers.c \
listpart.c \
docs.c
# include dirs
LOCAL_C_INCLUDES = $(LOCAL_PATH)/include
# compiler flags settings
ifeq ($(ENABLE_DEBUGGING), true)
LOCAL_CFLAGS = -O3 -g -Wall -Wextra $(EXTRA_COMPILER_FLAGS)
else ifeq ($(ENABLE_DEBUGGING), false)
LOCAL_CFLAGS = -O3 -Wall $(EXTRA_COMPILER_FLAGS)
else
$(warning Unknown debugging flag: $(ENABLE_DEBUGGING). Please see: $(PREDIR)/config/env.mk. Using non-debugging flags)
LOCAL_CFLAGS = -O3 -Wall $(EXTRA_COMPILER_FLAGS)
endif
include $(BUILD_EXECUTABLE)
# end

26
jni/Application.mk Executable file
View File

@@ -0,0 +1,26 @@
# By YZBruh
# Copyright 2024 Partition Manager
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# architecture
APP_ABI := \
arm64-v8a \
armeabi-v7a
APP_PLATFORM := android-21
APP_OPTIM := release
# end

83
jni/checkers.c Executable file
View File

@@ -0,0 +1,83 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include <pmt.h>
extern bool pmt_use_cust_cxt;
extern bool pmt_ab;
extern bool pmt_logical;
extern bool pmt_force_mode;
extern char *cust_cxt;
/* check parts */
void check_psf()
{
/* true = ab | false = a */
if (pmt_use_cust_cxt)
{
static char cust_cxt_ck_path[150];
sprintf(cust_cxt_ck_path, "%s/boot_a", cust_cxt);
if (access(cust_cxt_ck_path, F_OK) != 0) pmt_ab = false;
else pmt_ab = true;
} else {
if (access("/dev/block/by-name/boot_a", F_OK) != 0) pmt_ab = false;
else pmt_ab = true;
}
/* true = logical | false = classic */
if (pmt_use_cust_cxt)
{
static char cust_cxt_ckl_path[150];
sprintf(cust_cxt_ckl_path, "%s/super", cust_cxt);
if (access(cust_cxt_ckl_path, F_OK) != 0) pmt_logical = false;
else pmt_logical = true;
} else {
if (access("/dev/block/by-name/super", F_OK) != 0) pmt_logical = false;
else pmt_logical = true;
}
}
/* root checker function */
void check_root()
{
/* a quick, easy method to verify root :D */
if (getuid() != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, ANSI_RED "Root privileges could not be detected! Please run this binary with root. Error reason: %s\n" ANSI_RESET, strerror(errno));
exit(27);
} else exit(27);
}
}
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */

31
jni/config/env.mk Executable file
View File

@@ -0,0 +1,31 @@
# By YZBruh
# Copyright 2024 Partition Manager
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#########################################
# #
# Configuration Flags #
# #
# Warning: you can edit #
# #
#########################################
# addionital compiler flags
EXTRA_COMPILER_FLAGS ?=
# debugging mode (binary)
ENABLE_DEBUGGING ?= false
# end of environment configuration

66
jni/docs.c Executable file
View File

@@ -0,0 +1,66 @@
/* By YZBruh */
/*
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdio.h>
#include <pmt-docs.h>
void licenses()
{
printf("Copyright 2024 Partition Manager\n");
printf("Licensed under the Apache License, Version 2.0 (the \"License\");\n");
printf("you may not use this file except in compliance with the License.\n");
printf("You may obtain a copy of the License at\n\n");
printf(" http://www.apache.org/licenses/LICENSE-2.0\n\n");
printf("Unless required by applicable law or agreed to in writing, software\n");
printf("distributed under the License is distributed on an \"AS IS\" BASIS,\n");
printf("WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n");
printf("See the License for the specific language governing permissions and limitations under the License.\n");
}
void help()
{
printf("Usage: \n");
printf(" -b | --backup backup mode\n");
printf(" -F | --flash flash mode\n");
printf(" -r | --format format mode (only ext2/3/4 file systems)\n");
printf(" -p | --partition name of the partition to be backed up\n");
printf(" -l | --logical know that the partition that will be backed up is logical\n");
printf(" -o | --out (only backups) the output name of the backed-up partition (default: partition name)\n");
printf(" -d | --outdir (only backups) directory where the backup partition will be saved (default: /storage/emulated/0)\n");
printf(" -c | --context it is meant to specify a custom /dev context. Only classic partitions (default: /dev/block/by-name)\n");
printf(" -D | --list list partitions\n");
printf(" -f | --force force mode. Output is not produced. Even if it's a mistake. But if the target is not a mode, the error is given. If you want to work stable, it is important to specify this option first.\n");
printf(" -v | --version see version\n");
printf(" --help see help message\n");
printf(" -L | --license see license\n\n");
printf("Examples:\n");
printf(" -b --partition boot_a -o boot_slot_a_image -d /sdcard/backup -c /dev/block/platform/bootdevice/by-name\n");
printf(" --flash /sdcard/twrp/boot.img -p boot_a -c /dev/block/platform/bootdevice/by-name\n");
printf(" -c /dev/block/platform/bootdevice/by-name --list\n\n");
printf("Report bugs to <yagizzengin73@gmail.com>\n");
}
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */

30
jni/include/pmt-docs.h Executable file
View File

@@ -0,0 +1,30 @@
/* By YZBruh */
/*
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
void help();
void licenses();
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end */

32
jni/include/pmt-versioning.h Executable file
View File

@@ -0,0 +1,32 @@
/* By YZBruh */
/*
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
/* versioning */
#define PMT_MAJOR 2
#define PMT_LEVEL 0
#define PMT_PATCH 0
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end */

64
jni/include/pmt.h Executable file
View File

@@ -0,0 +1,64 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#if !defined(__PMT_H_)
#define __PMT_H_
/* some definations */
#define ANSI_RED "\033[31m"
#define ANSI_YELLOW "\033[33m"
#define ANSI_GREEN "\033[32m"
#define ANSI_RESET "\033[0m"
#define PMT_PACKAGE_NAME "Partition Manager"
/* variable definations */
extern char *out;
extern char *outdir;
extern char *cust_cxt;
extern char *target_partition;
extern char *target_flash_file;
extern char *format_fs;
extern char *partition_type;
extern bool pmt_use_logical;
extern bool pmt_use_cust_cxt;
extern bool pmt_ab;
extern bool pmt_logical;
extern bool pmt_flash;
extern bool pmt_backup;
extern bool pmt_format;
extern bool pmt_force_mode;
/* function definations */
void listpart();
void check_psf();
void check_root();
void pmt(unsigned short progress_code);
void version();
#endif /* __PMT_H_ */
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */

90
jni/listpart.c Executable file
View File

@@ -0,0 +1,90 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdbool.h>
#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <pmt.h>
extern bool pmt_use_cust_cxt;
extern bool pmt_ab;
extern bool pmt_logical;
extern bool pmt_force_mode;
extern char *cust_cxt;
/* list existing partitions */
void listpart() {
DIR *dir;
struct dirent *entry;
if (pmt_use_cust_cxt)
{
dir = opendir(cust_cxt);
if (dir == NULL)
{
if (!pmt_force_mode) {
fprintf(stderr, "Could not open: `%s`. Error reason: %s\n", cust_cxt, strerror(errno));
exit(62);
} else exit(62);
}
} else {
dir = opendir("/dev/block/by-name");
if (dir == NULL)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Could not open: `/dev/block/by-name`. Error reason: %s\n", strerror(errno));
exit(63);
} else exit(63);
}
}
while ((entry = readdir(dir)) != NULL) {
printf("%s\n", entry->d_name);
}
closedir(dir);
if (pmt_logical)
{
printf("List of logical partitions (/dev/block/mapper): \n");
if (system("ls /dev/block/mapper") != 0 && !pmt_force_mode)
{
fprintf(stderr, "%sAn error occurred when the logical partition list appears!%s\n", ANSI_RED, ANSI_RESET);
exit(64);
}
}
if (pmt_ab && !pmt_force_mode) printf("%sWarning: device using A/B partition style.%s\n", ANSI_YELLOW, ANSI_RESET);
if (pmt_logical && !pmt_force_mode) printf("%sWarning: device using logical partition type.%s\n", ANSI_YELLOW, ANSI_RESET);
}
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */

404
jni/pmt.c Executable file
View File

@@ -0,0 +1,404 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* force use C std (if default is C++) */
#if defined(__cplusplus)
extern "C" {
#endif
/* include needed libs (headers) */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <string.h>
#include <stdbool.h>
#include <getopt.h>
#include <errno.h>
#include <pmt.h>
#include <pmt-docs.h>
/* add value to variables that are added globally and are not worth */
char *out = NULL;
char *outdir = NULL;
char *cust_cxt = NULL;
char *target_partition = NULL;
char *target_flash_file = NULL;
char *partition_type = NULL;
char *format_fs = NULL;
bool pmt_use_logical = NULL;
bool pmt_use_cust_cxt = NULL;
bool pmt_ab = false;
bool pmt_logical = false;
bool pmt_flash = false;
bool pmt_backup = false;
bool pmt_format = false;
bool pmt_force_mode = false;
/* classic main function (C binary here xd) */
int main(int argc, char *argv[])
{
/* check argument total */
if (argc < 2)
{
fprintf(stderr, "%s: missing operand\nTry `%s --help' for more information.\n", argv[0], argv[0]);
exit(44);
}
/* a structure for long arguments... */
struct option long_options[] = {
{"backup", no_argument, 0, 'b'},
{"flash", required_argument, 0, 'F'},
{"format", required_argument, 0, 'r'},
{"partition", required_argument, 0, 'p'},
{"logical", no_argument, 0, 'l'},
{"out", required_argument, 0, 'o'},
{"outdir", required_argument, 0, 'd'},
{"context", required_argument, 0, 'c'},
{"list", no_argument, 0, 'D'},
{"force", no_argument, 0, 'f'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 0},
{"license", no_argument, 0, 'L'},
{0, 0, 0, 0}
};
/* boolean statements (only valid in this file) to distinguish. and pointer from a shortcut for the symbol rule */
static bool wiew_help = false;
static bool wiew_licenses = false;
static bool wiew_version = false;
static bool list_partitions = false;
static bool combo_wiewers = false;
static bool use_cust_outdir = false;
static char *opt_symbol = "-";
static char *common_symbol_rule;
common_symbol_rule = "When entering the attached argument of an option, an argument of another option type cannot be used. In short, the rule is: there can be no '-' at the beginning of the attached argument.";
int opt;
/* control for each argument */
while ((opt = getopt_long(argc, argv, "bF:rp:lo:d:c:DfvL", long_options, NULL)) != -1)
{
/* process arguments */
switch (opt)
{
/* backup mode */
case 'b':
pmt_backup = true;
break;
/* flash mode */
case 'F':
target_flash_file = strdup(optarg);
if (strncmp(target_flash_file, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s%s%s\n", ANSI_RED, common_symbol_rule, ANSI_RESET);
exit(19);
} else exit(19);
}
pmt_flash = true;
break;
/* format mode */
case 'r':
format_fs = strdup(optarg);
if (strncmp(format_fs, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s%s%s\n", ANSI_RED, common_symbol_rule, ANSI_RESET);
exit(19);
} else exit(19);
}
pmt_format = true;
break;
/* partition selector option */
case 'p':
target_partition = strdup(optarg);
if (strncmp(target_partition, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s%s%s\n", ANSI_RED, common_symbol_rule, ANSI_RESET);
exit(19);
} else exit(19);
}
break;
/* logical partitions option */
case 'l':
check_root();
check_psf();
if (pmt_logical)
{
pmt_use_logical = true;
} else {
if (!pmt_force_mode)
{
fprintf(stderr, "This device does not have logical partitions!\n");
exit(17);
} else exit(17);
}
break;
/* output file option */
case 'o':
out = strdup(optarg);
if (strncmp(out, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s%s%s\n", ANSI_RED, common_symbol_rule, ANSI_RESET);
exit(19);
} else exit(19);
}
break;
/* output dir option */
case 'd':
use_cust_outdir = true;
outdir = strdup(optarg);
break;
/* context selector option */
case 'c':
pmt_use_cust_cxt = true;
cust_cxt = strdup(optarg);
if (strncmp(cust_cxt, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s%s%s\n", ANSI_RED, common_symbol_rule, ANSI_RESET);
exit(19);
} else exit(19);
}
break;
/* partition lister function */
case 'D':
list_partitions = true;
/* check combo wiewer options and progress */
if (wiew_version || wiew_help || wiew_licenses) combo_wiewers = true;
break;
/* force mode option */
case 'f':
pmt_force_mode = true;
break;
/* version info option */
case 'v':
wiew_version = true;
/* check combo wiewer options and progress */
if (list_partitions || wiew_help || wiew_licenses) combo_wiewers = true;
break;
/* help message opption */
case 0:
wiew_help = true;
/* check combo wiewer options and progress */
if (wiew_version || list_partitions || wiew_licenses) combo_wiewers = true;
break;
/* license wiewer option */
case 'L':
wiew_licenses = true;
/* check combo wiewer options and progress */
if (wiew_version || wiew_help || list_partitions) combo_wiewers = true;
break;
/* for invalid options */
case '?':
printf("Try `%s --help' for more information.\n", argv[0]);
exit(43);
break;
default:
printf("Usage: %s [-b | --backup] [-f | --flash FILE] [-r | --format FS_TYPE] [-p | --partition PARTITION] [-l | --logical] [-o | --out OUTNAME] [-d | --outdir OUTDIR] [-c | --context] [-D | --list] [-v | --version] [--help] [-L | --license]\n", argv[0]);
exit(44);
}
}
/* stop the program if multiple viewer is used */
if (combo_wiewers)
{
fprintf(stderr, "%s: Multiple wiewers cannot be used at the same line.\n", argv[0]);
exit(81);
}
/* controller to handle viewer */
if (wiew_help)
{
help();
exit(EXIT_SUCCESS);
} else if (wiew_version)
{
version();
exit(EXIT_SUCCESS);
} else if (wiew_licenses)
{
licenses();
exit(EXIT_SUCCESS);
} else if (list_partitions)
{
check_root();
listpart();
exit(EXIT_SUCCESS);
}
/* target control is done */
if (!pmt_backup && !pmt_flash && !pmt_format)
{
fprintf(stderr, "%s: missing operand.\nTry `%s --help` for more information.\n", argv[0], argv[0]);
exit(3);
}
/* prevent multiple mode use */
if (pmt_backup && pmt_flash)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Backup and flash functions cannot be used in the same command.\n");
exit(9);
} else exit(9);
}
/* checks */
check_root();
check_psf();
if (pmt_format)
{
if (strcmp(format_fs, "ext4") != 0 || strcmp(format_fs, "ext3") != 0 || strcmp(format_fs, "ext2") != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: formatter: unsupported filesystem: %s", argv[0], format_fs);
exit(41);
} else exit(41);
}
}
if (use_cust_outdir)
{
if (strncmp(outdir, opt_symbol, 1) == 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s\n", common_symbol_rule);
exit(19);
} else exit(19);
}
struct stat out_info;
if (stat(outdir, &out_info) != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: cannot stat '%s': %s\n", argv[0], outdir, strerror(errno));
exit(18);
} else exit(18);
} else {
if (!S_ISDIR(out_info.st_mode))
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: %s: is a not directory.\n", argv[0], outdir);
exit(20);
} else exit(20);
}
}
}
if (pmt_flash)
{
struct stat flashf_info;
if (stat(target_flash_file, &flashf_info) != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: cannot stat '%s': %s\n", argv[0], target_flash_file, strerror(errno));
exit(15);
} else exit(15);
} else {
if (!S_ISREG(flashf_info.st_mode))
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: %s: is a not file.\n", argv[0], target_flash_file);
exit(16);
} else exit(16);
}
}
}
/* custom context checker */
if (pmt_use_cust_cxt)
{
struct stat cxtinfo;
if (stat(cust_cxt, &cxtinfo) == 0)
{
if (!S_ISREG(cxtinfo.st_mode))
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: %s: is a not directory.\n", argv[0], cust_cxt);
exit(8);
} else exit(8);
}
} else {
if (!pmt_force_mode)
{
fprintf(stderr, "%s: %s: %s\n", argv[0], cust_cxt, strerror(errno));
exit(6);
} else exit(6);
}
if (strstr(cust_cxt, "/dev") == NULL && !pmt_force_mode)
{
fprintf(stderr, "%sYou're going through my wave? There's nothing about this /dev. Use force mode if you don't want this error%s\n", ANSI_YELLOW, ANSI_RESET);
exit(81);
}
}
if (target_partition == NULL)
{
if (!pmt_force_mode)
{
fprintf(stderr, "%s: required partition name.\nTry `%s --help' for more information.\n", argv[0], argv[0]);
exit(5);
} else exit(5);
} else {
/**
*
* 1 = backup mode
*
* 2 = flash mode
*
* 3 = format
*/
if (pmt_backup)
{
pmt(1);
exit(EXIT_SUCCESS);
} else if (pmt_flash)
{
pmt(2);
exit(EXIT_SUCCESS);
} else if (pmt_format)
{
pmt(3);
} else {
fprintf(stderr, "%s: no target (backup or flash).\nTry `%s --help` for more information.\n", argv[0], argv[0]);
exit(3);
}
}
}
#if defined(__cplusplus)
}
#endif
/* end of code */

299
jni/tools.c Executable file
View File

@@ -0,0 +1,299 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <string.h>
#include <stdbool.h>
#include <stddef.h>
#include <errno.h>
#include <fcntl.h>
#include <pmt.h>
#define BFSIZE 1024
extern char *out;
extern char *outdir;
extern char *format_fs;
extern char *cust_cxt;
extern char *target_partition;
extern char *target_flash_file;
extern char *partition_type;
extern bool pmt_use_logical;
extern bool pmt_use_cust_cxt;
extern bool pmt_logical;
extern bool pmt_flash;
extern bool pmt_backup;
extern bool pmt_force_mode;
/**
*
* if progress_code is a
* 1 = backup mode
*
* 2 = flash mode
*
* 3 = format mode
*/
static double
calc_flsz(char *filepath)
{
static int calc_flsz_file;
calc_flsz_file = open(filepath, O_RDONLY);
if (calc_flsz_file == -1) return -1;
off_t flsz = lseek(calc_flsz_file, 0, SEEK_END);
close(calc_flsz_file);
if (flsz == (off_t)-1) return -1;
return (double)flsz / (1024 * 1024);
}
void pmt(unsigned short progress_code)
{
/* required variables */
static int srcf, targetf;
static char backupper_path[512];
static char ppath[100];
static char formatter_cmd[200];
static char outf[512];
static char flasher_path[512];
static char buffer[BFSIZE];
static ssize_t bytesRead;
static unsigned long long bytesCopied = 0;
static unsigned long long count = 1024 * 1024 * 1024;
if (progress_code == 1)
{
if (!pmt_use_logical)
{
if (pmt_use_cust_cxt) sprintf(backupper_path, "%s/%s", cust_cxt, target_partition);
else sprintf(backupper_path, "/dev/block/by-name/%s", target_partition);
} else if (pmt_use_logical) sprintf(backupper_path, "/dev/block/mapper/%s", target_partition);
else {
if (!pmt_force_mode)
{
fprintf(stderr, "İnvalid partition type!\n");
exit(28);
} else exit(28);
}
if (access(backupper_path, F_OK) == -1)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Partition not found!\n");
exit(29);
} else exit(29);
}
if (calc_flsz(backupper_path) != -1 && !pmt_force_mode) printf("Disk size of the partition to be backed up: %.2f\n", calc_flsz(backupper_path));
else printf("%sFailed to target partition disk size%s\n", ANSI_YELLOW, ANSI_RESET);
srcf = open(backupper_path, O_RDONLY);
if (srcf == -1) {
if (!pmt_force_mode)
{
fprintf(stderr, "Couldn't read: %s: %s", backupper_path, strerror(errno));
exit(39);
} else exit(39);
}
/* determine output */
if (outdir != NULL)
{
if (out != NULL) sprintf(outf, "%s/%s.img", outdir, out);
else sprintf(outf, "%s/%s.img", outdir, target_partition);
} else {
if (out != NULL) sprintf(outf, "/storage/emulated/0/%s.img", out);
else sprintf(outf, "/storage/emulated/0/%s.img", target_partition);
}
targetf = open(outf, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (targetf == -1) {
if (!pmt_force_mode)
{
fprintf(stderr, "Couldn't generate: %s: %s", outf, strerror(errno));
exit(37);
} else exit(37);
}
/* start writing */
while ((bytesRead = read(srcf, buffer, BFSIZE)) > 0 && bytesCopied < count)
{
ssize_t bytesWritten = write(targetf, buffer, bytesRead);
if (bytesWritten != bytesRead)
{
fprintf(stderr, "Couldn't write: %s: %s", backupper_path, strerror(errno));
close(srcf);
close(targetf);
exit(81);
}
bytesCopied += bytesWritten;
}
/* close files */
close(srcf);
close(targetf);
/* Print the output information by evaluating all situations */
if (outdir != NULL)
{
if (out != NULL) printf("%sSuccess. Output: %s/%s.img%s\n", ANSI_GREEN, outdir, out, ANSI_RESET);
else printf("%sSuccess. Output: %s/%s.img%s\n", ANSI_GREEN, outdir, target_partition, ANSI_RESET);
} else {
if (out != NULL) printf("%sSuccess. Output: /storage/emulated/0/%s.img%s\n", ANSI_GREEN, out, ANSI_RESET);
else printf("%sSuccess. Output: /storage/emulated/0/%s.img%s\n", ANSI_GREEN, target_partition, ANSI_RESET);
}
} else if (progress_code == 2)
{
/* determine device block */
/* for classic */
if (!pmt_use_logical)
{
if (pmt_use_cust_cxt) sprintf(flasher_path, "%s/%s", cust_cxt, target_partition);
else sprintf(flasher_path, "/dev/block/by-name/%s", target_partition);
/* for logical */
} else if (pmt_use_logical) sprintf(flasher_path, "/dev/block/mapper/%s", target_partition);
else {
if (!pmt_force_mode)
{
fprintf(stderr, "İnvalid partition type!\n");
exit(30);
} else exit(30);
}
/* check partition */
if (access(flasher_path, F_OK) == -1)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Partition not found!\n");
exit(31);
} else exit(31);
}
if (calc_flsz(target_flash_file) != -1 && !pmt_force_mode) printf("Size of flash file: %.2f\n", calc_flsz(target_flash_file));
else printf("%sFailed to get flash file size%s\n", ANSI_YELLOW, ANSI_RESET);
if (calc_flsz(target_partition) != -1 && !pmt_force_mode) printf("Disk size of the target partition: %.2f\n", calc_flsz(target_partition));
else printf("%sFailed to get target partition disk size%s\n", ANSI_YELLOW, ANSI_RESET);
srcf = open(target_flash_file, O_RDONLY);
if (srcf == -1) {
if (!pmt_force_mode)
{
fprintf(stderr, "Couldn't read: %s: %s", target_flash_file, strerror(errno));
exit(39);
} else exit(39);
}
targetf = open(target_partition, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (targetf == -1) {
if (!pmt_force_mode)
{
fprintf(stderr, "Couldn't read: %s: %s", target_partition, strerror(errno));
exit(37);
} else exit(37);
}
/* start writing */
while ((bytesRead = read(srcf, buffer, BFSIZE)) > 0 && bytesCopied < count) {
ssize_t bytesWritten = write(targetf, buffer, bytesRead);
if (bytesWritten != bytesRead) {
fprintf(stderr, "Couldn't write: %s: %s", backupper_path, strerror(errno));
close(srcf);
close(targetf);
exit(81);
}
bytesCopied += bytesWritten;
}
close(srcf);
close(targetf);
if (!pmt_force_mode) printf("%sSuccess.%s\n", ANSI_GREEN, ANSI_RESET);
} else if (progress_code == 3)
{
/* generate partition extn */
if (!pmt_use_logical)
{
if (pmt_use_cust_cxt) sprintf(ppath, "%s/%s", cust_cxt, target_partition);
else sprintf(ppath, "/dev/block/by-name/%s", target_partition);
/* for logical */
} else if (pmt_use_logical) sprintf(ppath, "/dev/block/mapper/%s", target_partition);
else {
if (!pmt_force_mode)
{
fprintf(stderr, "İnvalid partition type!\n");
exit(49);
} else exit(49);
}
/* check partition */
if (access(ppath, F_OK) == -1)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Partition not found!\n");
} else exit(31);
}
/* get target partition block size */
struct statvfs file_sys_inf;
if (statvfs(ppath, &file_sys_inf) != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "The partition block size could not be obtained!\n");
exit(49);
} else exit(49);
}
/* generate mke2fs command */
sprintf(formatter_cmd, "mke2fs -Fq -t %s -b %lu %s", format_fs, file_sys_inf.f_bsize, ppath);
/* run command */
if (system(formatter_cmd) != 0)
{
if (!pmt_force_mode)
{
fprintf(stderr, "Formatting failed! There may be a chance that something has been damaged!\n");
exit(71);
} else exit(71);
}
}
}
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */

51
jni/versioner.c Executable file
View File

@@ -0,0 +1,51 @@
/* By YZBruh */
/**
* Copyright 2024 Partition Manager
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if defined(__cplusplus)
extern "C" {
#endif
#include <stdio.h>
#include <pmt-versioning.h>
void version()
{
printf("Version: %d.%d.%d (code %d%d%d) ", PMT_MAJOR, PMT_LEVEL, PMT_PATCH, PMT_MAJOR, PMT_LEVEL, PMT_PATCH);
#if __SIZEOF_POINTER__ == 4
printf("32-bit binary\n");
#elif __SIZEOF_POINTER__ == 8
printf("64-bit binary\n");
#else
printf("\n");
#endif
#if defined(__clang__)
printf("Compiler: clang %s\n", __clang_version__);
#elif defined(__gcc__)
printf("Compiler: gcc %s\n", __gcc_version__)
#endif
printf("See licenses with -L argument.\n");
}
#if defined(__cplusplus)
}
#endif /* __cplusplus */
/* end of code */