自学教程：C++ ErrorAbort函数代码示例

/* verify_trustzone("TZ_VERSION", "TZ_VERSION", ...) */Value * VerifyTrustZoneFn(const char *name, State *state, int argc, Expr *argv[]) {    char current_tz_version[TZ_VER_BUF_LEN];    int i, ret;    ret = get_tz_version(current_tz_version, TZ_VER_BUF_LEN);    if (ret) {        return ErrorAbort(state, "%s() failed to read current TZ version: %d",                          name, ret);    }    char** tz_version = ReadVarArgs(state, argc, argv);    if (tz_version == NULL) {        return ErrorAbort(state, "%s() error parsing arguments", name);    }    ret = 0;    for (i = 0; i < argc; i++) {        uiPrintf(state, "Comparing TZ version %s to %s",                 tz_version[i], current_tz_version);        if (strncmp(tz_version[i], current_tz_version, strlen(tz_version[i])) == 0) {            ret = 1;            break;        }    }    for (i = 0; i < argc; i++) {        free(tz_version[i]);    }    free(tz_version);    return StringValue(strdup(ret ? "1" : "0"));}

Value* UpdateFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1) {        return ErrorAbort(state, "%s() expects 6 args, got %d", name, argc);    }    char* type = strrchr(name, '_');    if (type == NULL || *(type+1) == '/0') {        return ErrorAbort(state, "%s() couldn't get type from function name",                          name);    }    ++type;    Value* image;    if (ReadValueArgs(state, argv, 1, &image) <0) {        return NULL;    }    if (image->type != VAL_BLOB) {        printf("image argument is not blob (is type %d)/n", image->type);        goto done;    }    install_firmware_update(type, image->data, image->size, "/tmp/recovery.log");    printf("%s: install_firmware_update returned!/n", name);  done:    FreeValue(image);    // install_firmware_update should reboot.  If it returns, it failed.    return StringValue(strdup(""));}

Value* WriteBootloaderFn(const char* name, State* state, int argc, Expr* argv[]){    int result = -1;    Value* img;    Value* xloader_loc;    Value* sbl_loc;    if (argc != 3) {        return ErrorAbort(state, "%s() expects 3 args, got %d", name, argc);    }    if (ReadValueArgs(state, argv, 3, &img, &xloader_loc, &sbl_loc) < 0) {        return NULL;    }    if(img->type != VAL_BLOB ||       xloader_loc->type != VAL_STRING ||       sbl_loc->type != VAL_STRING) {      FreeValue(img);      FreeValue(xloader_loc);      FreeValue(sbl_loc);      return ErrorAbort(state, "%s(): argument types are incorrect", name);    }    result = update_bootloader(img->data, img->size,                               xloader_loc->data, sbl_loc->data);    FreeValue(img);    FreeValue(xloader_loc);    FreeValue(sbl_loc);    return StringValue(strdup(result == 0 ? "t" : ""));}

// Read a local file and return its contents (the Value* returned// is actually a FileContents*).Value* ReadFileFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1) {        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    }    char* filename;    if (ReadArgs(state, argv, 1, &filename) < 0) return NULL;    Value* v = malloc(sizeof(Value));    v->type = VAL_BLOB;    FileContents fc;    if (LoadFileContents(filename, &fc, RETOUCH_DONT_MASK) != 0) {        ErrorAbort(state, "%s() loading /"%s/" failed: %s",                   name, filename, strerror(errno));        free(filename);        free(v);        free(fc.data);        return NULL;    }    v->size = fc.size;    v->data = (char*)fc.data;    free(filename);    return v;}

Value *CommandFunction(int (*fun) (int, char **), const char *name, State * state, int argc, Expr * argv[]){	Value *ret = NULL;	char *argv_str[argc + 1];	int i;	char **argv_read = ReadVarArgs(state, argc, argv);	if (argv_read == NULL) {		ErrorAbort(state, "%s parameter parsing failed.", name);		goto done;	}	argv_str[0] = (char *)name;	for (i = 0; i < argc; i++)		argv_str[i + 1] = argv_read[i];	if (fun(sizeof(argv_str) / sizeof(char *), argv_str) != EXIT_SUCCESS) {		ErrorAbort(state, "%s failed.", name);		goto done;	}	for (i = 0; i < argc; i++)		free(argv_read[i]);	free(argv_read);	ret = StringValue(strdup("t"));done:	return ret;}

Value* UnmountFn(const char* name, State* state, int argc, Expr* argv[]) {    char* result = NULL;    if (argc != 1) {        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    }    char* mount_point;    if (ReadArgs(state, argv, 1, &mount_point) < 0) {        return NULL;    }    if (strlen(mount_point) == 0) {        ErrorAbort(state, "mount_point argument to unmount() can't be empty");        goto done;    }    scan_mounted_volumes();    const MountedVolume* vol = find_mounted_volume_by_mount_point(mount_point);    if (vol == NULL) {        fprintf(stderr, "unmount of %s failed; no such volume/n", mount_point);        result = strdup("");    } else {        unmount_mounted_volume(vol);        result = mount_point;    }done:    if (result != mount_point) free(mount_point);    return StringValue(result);}

Value *ExecuteOsipFunction(const char *name, State * state, int argc, Expr * argv[], int (*action) (char *)){	Value *ret = NULL;	char *destination = NULL;	if (ReadArgs(state, argv, 1, &destination) < 0) {		return NULL;	}	if (destination == NULL || strlen(destination) == 0) {		ErrorAbort(state, "destination argument to %s can't be empty", name);		goto done;	}	if (action(destination) == -1) {		ErrorAbort(state, "Error writing %s to OSIP", destination);		goto done;	}	ret = StringValue(strdup("t"));done:	if (destination)		free(destination);	return ret;}

char* UnloadWifiFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 0)        return ErrorAbort(state, "%s() expects 0 arg, got %d", name, argc);    if (wifi_unload_driver() != 0) {        return ErrorAbort(state, "Unable to unload wifi-driver: %s", strerror(errno));    }    return strdup("t");}

// write_raw_image(file, partition)Value* WriteRawImageFn(const char* name, State* state, int argc, Expr* argv[]) {    char* result = NULL;    char* partition;    char* filename;    if (ReadArgs(state, argv, 2, &filename, &partition) < 0) {        return NULL;    }    if (strlen(partition) == 0) {        ErrorAbort(state, "partition argument to %s can't be empty", name);        goto done;    }    if (strlen(filename) == 0) {        ErrorAbort(state, "file argument to %s can't be empty", name);        goto done;    }    mtd_scan_partitions();    const MtdPartition* mtd = mtd_find_partition_by_name(partition);    if (mtd == NULL) {        fprintf(stderr, "%s: no mtd partition named /"%s/"/n", name, partition);        result = strdup("");        goto done;    }    char mtddevname[32]="";    sprintf(mtddevname, "/dev/mtd/mtd%d", mtd_get_partition_index((MtdPartition*)mtd));    bool success;    FILE* f = fopen(filename, "rb");    if (f == NULL) {        fprintf(stderr, "%s: can't open %s: %s/n",                name, filename, strerror(errno));        result = strdup("");        goto done;    }    success = !write_recovery(filename, partition);    printf("%s %s partition from %s/n",           success ? "wrote" : "failed to write", partition, filename);    result = success ? partition : strdup("");done:    if (result != partition) free(partition);    free(filename);    return StringValue(result);}

Value* RangeSha1Fn(const char* name, State* state, int argc, Expr* argv[]) {    Value* blockdev_filename;    Value* ranges;    const uint8_t* digest = NULL;    if (ReadValueArgs(state, argv, 2, &blockdev_filename, &ranges) < 0) {        return NULL;    }    if (blockdev_filename->type != VAL_STRING) {        ErrorAbort(state, "blockdev_filename argument to %s must be string", name);        goto done;    }    if (ranges->type != VAL_STRING) {        ErrorAbort(state, "ranges argument to %s must be string", name);        goto done;    }    int fd = open(blockdev_filename->data, O_RDWR);    if (fd < 0) {        ErrorAbort(state, "failed to open %s: %s", blockdev_filename->data, strerror(errno));        goto done;    }    RangeSet* rs = parse_range(ranges->data);    uint8_t buffer[BLOCKSIZE];    SHA_CTX ctx;    SHA_init(&ctx);    int i, j;    for (i = 0; i < rs->count; ++i) {        check_lseek(fd, (off64_t)rs->pos[i*2] * BLOCKSIZE, SEEK_SET);        for (j = rs->pos[i*2]; j < rs->pos[i*2+1]; ++j) {            readblock(fd, buffer, BLOCKSIZE);            SHA_update(&ctx, buffer, BLOCKSIZE);        }    }    digest = SHA_final(&ctx);    close(fd);  done:    FreeValue(blockdev_filename);    FreeValue(ranges);    if (digest == NULL) {        return StringValue(strdup(""));    } else {        return StringValue(PrintSha1(digest));    }}

char* UnloadWifiFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 0)        return ErrorAbort(state, "%s() expects 0 arg, got %d", name, argc); void *h = dlopen("/system/lib/libhardware_legacy.so",RTLD_LAZY); int (*wifi_unload_driver)() = dlsym(h,"wifi_unload_driver");  if (wifi_unload_driver) {    if (wifi_unload_driver() != 0) {      return ErrorAbort(state, "Unable to unload wifi-driver: %s", strerror(errno));    }    return strdup("t");  }  return ErrorAbort(state, "libhardware_legacy is not available.");}

Value* WipeCacheFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 0) {        return ErrorAbort(state, "%s() expects no args, got %d", name, argc);    }    fprintf(((UpdaterInfo*)(state->cookie))->cmd_pipe, "wipe_cache/n");    return StringValue(strdup("t"));}

char* WriteFileFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 2)        return ErrorAbort(state, "%s() expects 2 args, got %d", name, argc);    char *filename;    char *line;    int retval;    if (ReadArgs(state, argv, 2, &filename, &line) < 0)        return NULL;    FILE *fd;    if (! (fd = fopen(filename, "w")) ) {      fprintf(stderr, "Can't open %s for write /n", filename);      free(filename);      free(line);      return strdup("");    }    if (fwrite(line, strlen(line), 1, fd) == 1) {      fclose(fd);      free(filename);      free(line);      return strdup("t");    } else {      fclose(fd);      free(filename);      free(line);      return strdup("");    }}

char* ModuleLoadedFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1)        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    char *module_name;    int retval;    if (ReadArgs(state, argv, 1, &module_name) < 0)        return NULL;    int module_found = -1;    FILE *modules;    char buffer[READ_BUF_SIZE];    char mname[READ_BUF_SIZE];    if (! (modules = fopen("/proc/modules", "r")) ) {      fprintf(stderr, "Can't open /proc/modules for read /n");      return strdup("");    }    while(fgets(buffer, sizeof(buffer), modules)) {      /* process the line */        sscanf(buffer, "%s %*s", mname);        if ((strstr(mname, module_name)) != NULL) {          module_found = 0;        }    }    fclose(modules);    free(module_name);    return (module_found == 0 ? strdup("t") : strdup(""));}

// package_extract_dir(package_path, destination_path)Value *PackageExtractDirFn (const char *name, State * state, int argc, Expr * argv[]){  if (argc != 2)	  {	    return ErrorAbort (state, "%s() expects 2 args, got %d", name,			       argc);	  }  char *zip_path;  char *dest_path;  if (ReadArgs (state, argv, 2, &zip_path, &dest_path) < 0)    return NULL;  ZipArchive *za = ((UpdaterInfo *) (state->cookie))->package_zip;  // To create a consistent system image, never use the clock for timestamps.  struct utimbuf timestamp = { 1217592000, 1217592000 };	// 8/1/2008 default  bool success = mzExtractRecursive (za, zip_path, dest_path,				     MZ_EXTRACT_FILES_ONLY, &timestamp,				     NULL, NULL);  free (zip_path);  free (dest_path);  return StringValue (strdup (success ? "t" : ""));}

char* WhiteListMacsFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1)        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    char *filename;    int retval;    int returncode = 0;    if (ReadArgs(state, argv, 1, &filename) < 0)        return NULL;    if (file_exists(filename) == 0) {    FILE *macs;    char buffer[20];    char command[100];    if (! (macs = fopen(filename, "r")) ) {      fprintf(stderr, "Can't open %s for read /n", filename);      free(filename);      return strdup("");    }    while(fgets(buffer, sizeof(buffer), macs) && returncode == 0) {        /* process the line */      sscanf(buffer, "%s", buffer);      sprintf(command,"/data/data/za.co.csir.walkiemesh/bin/iptables -t nat -I PREROUTING -m mac --mac-source %s -j ACCEPT", buffer);      //fprintf(stdout, "Enabling whitelist for: %s /n", command);      returncode = system(command);    }    fclose(macs);  }  free(filename);  return (returncode == 0 ? strdup("t") : strdup(""));}

// log("some message");// log("t", "some message");char* LogFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1 && argc != 2) {        return ErrorAbort(state, "%s() expects 1 or 2 args", name);    }    char *status;    char *message;    time_t time_now;    time(&time_now);    if (argc == 1) {      if (ReadArgs(state, argv, 1, &message) < 0)        return NULL;      status = strdup("t");    } else {      if (ReadArgs(state, argv, 2, &status, &message) < 0)        return NULL;    }    if (strcmp(status,"t") == 0) {      fprintf(((UpdaterInfo*)(state->cookie))->log_fd,        "<div class=/"date/">%s</div><div class=/"action/">%s...</div><div class=/"output/"></div><div class=/"done/">done</div><hr>",asctime(localtime(&time_now)),message);    }    else {      property_set("tether.status","failed");      fprintf(((UpdaterInfo*)(state->cookie))->log_fd,        "<div class=/"date/">%s</div><div class=/"action/">%s...</div><div class=/"output/"></div><div class=/"failed/">failed</div><hr>",asctime(localtime(&time_now)),message);    }    return strdup("");}

// symlink target src1 src2 ...//    unlinks any previously existing src1, src2, etc before creating symlinks.Value* SymlinkFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc == 0) {        return ErrorAbort(state, "%s() expects 1+ args, got %d", name, argc);    }    char* target;    target = Evaluate(state, argv[0]);    if (target == NULL) return NULL;    char** srcs = ReadVarArgs(state, argc-1, argv+1);    if (srcs == NULL) {        free(target);        return NULL;    }    int i;    for (i = 0; i < argc-1; ++i) {        if (unlink(srcs[i]) < 0) {            if (errno != ENOENT) {                fprintf(stderr, "%s: failed to remove %s: %s/n",                        name, srcs[i], strerror(errno));            }        }        if (symlink(target, srcs[i]) < 0) {            fprintf(stderr, "%s: failed to symlink %s to %s: %s/n",                    name, srcs[i], target, strerror(errno));        }        free(srcs[i]);    }    free(srcs);    return StringValue(strdup(""));}

char* InsModuleFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 2)        return ErrorAbort(state, "%s() expects 2 args, got %d", name, argc);    char *module_name;    char *options;    if (ReadArgs(state, argv, 2, &module_name, &options) < 0) {      return NULL;    }    ssize_t len;    void *image;    int rc;    if (!options)      options = "";    len = INT_MAX - 4095;    errno = ENOMEM;    image = read_file(module_name, &len);    if (!image)      return  strdup("");    errno = 0;    init_module(image, len, options);    rc = errno;    free(image);    free(module_name);    return (rc == 0 ? strdup("t") : strdup(""));}

Value *ShowProgressFn (const char *name, State * state, int argc, Expr * argv[]){  if (argc != 2)	  {	    return ErrorAbort (state, "%s() expects 2 args, got %d", name,			       argc);	  }  char *frac_str;  char *sec_str;  if (ReadArgs (state, argv, 2, &frac_str, &sec_str) < 0)	  {	    return NULL;	  }  double frac = strtod (frac_str, NULL);  int sec = strtol (sec_str, NULL, 10);  UpdaterInfo *ui = (UpdaterInfo *) (state->cookie);  fprintf (ui->cmd_pipe, "progress %f %d/n", frac, sec);  free (sec_str);  return StringValue (frac_str);}

Value* DownloadModemFn(const char* name, State* state, int argc, Expr* argv[]) {    char* modemImg;    int result = -1;    if (argc != 1)        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    if (ReadArgs(state, argv, 1, &modemImg) != 0) {        return NULL;    }    printf("DownloadModemFn: %s/n", modemImg);    result = DownloadFiles(modemImg);    if (result < 0) {        printf("Download failed!/n");    } else {        printf("Download success!/n");        ResetModem();        sleep(6);    }    return StringValue(strdup(result >= 0 ? "t" : ""));}

// apply_patch_check(file, [sha1_1, ...])Value* ApplyPatchCheckFn(const char* name, State* state,                         int argc, Expr* argv[]) {    if (argc < 1) {        return ErrorAbort(state, "%s(): expected at least 1 arg, got %d",                          name, argc);    }    char* filename;    if (ReadArgs(state, argv, 1, &filename) < 0) {        return NULL;    }    int patchcount = argc-1;    char** sha1s = ReadVarArgs(state, argc-1, argv+1);    int result = applypatch_check(filename, patchcount, sha1s);    int i;    for (i = 0; i < patchcount; ++i) {        free(sha1s[i]);    }    free(sha1s);    return StringValue(strdup(result == 0 ? "t" : ""));}

Value* FormatFn(const char* name, State* state, int argc, Expr* argv[]) {    char* result = NULL;    if (argc != 1) {        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    }        char *path;    if (ReadArgs(state, argv, 1, &path) < 0) {        return NULL;    }        ui_print("Formatting %s.../n", path);    if (0 != format_volume(path)) {        free(path);        return StringValue(strdup(""));    }        if (strcmp(path, "/data") == 0 && has_datadata()) {        ui_print("Formatting /datadata.../n", path);        if (0 != format_volume("/datadata")) {            free(path);            return StringValue(strdup(""));        }        if (0 != format_volume(get_android_secure_path())) {            free(path);            return StringValue(strdup(""));        }    }done:    return StringValue(strdup(path));}

Value *FlashOSImage(const char *name, State * state, int argc, Expr * argv[]){	char* result = NULL;	Value *funret = NULL;	char *image_type;	int ret;	Value* partition_value;	Value* contents;	if (ReadValueArgs(state, argv, 2, &contents, &partition_value) < 0) {		return NULL;	}	char* partition = NULL;	if (partition_value->type != VAL_STRING) {		ErrorAbort(state, "partition argument to %s must be string", name);		goto exit;	}	partition = partition_value->data;	if (strlen(partition) == 0) {		ErrorAbort(state, "partition argument to %s can't be empty", name);		goto exit;	}	if (contents->type == VAL_STRING && strlen((char*) contents->data) == 0) {		ErrorAbort(state, "file argument to %s can't be empty", name);		goto exit;	}	image_type = basename(partition);	ret = flash_image(contents->data, contents->size, image_type);	if (ret != 0) {		ErrorAbort(state, "%s: Failed to flash image %s, %s.",			   name, image_type, strerror(errno));		goto free;	}	funret = StringValue(strdup("t"));free:	free(image_type);exit:	return funret;}

char* Evaluate(State* state, Expr* expr) {    Value* v = expr->fn(expr->name, state, expr->argc, expr->argv);    if (v == NULL) return NULL;    if (v->type != VAL_STRING) {        ErrorAbort(state, "expecting string, got value type %d", v->type);        FreeValue(v);        return NULL;    }    char* result = v->data;    free(v);    return result;}

char* RmModuleFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1)        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    char *module_name;    int retval;    if (ReadArgs(state, argv, 1, &module_name) < 0)        return NULL;    retval = delete_module(module_name, O_NONBLOCK | O_EXCL);    free(module_name);    return (retval  == 0? strdup("t") : strdup(""));}

char* KillProcessByPIDFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc != 1)        return ErrorAbort(state, "%s() expects 1 arg, got %d", name, argc);    char *pidfile;    int retval;    if (ReadArgs(state, argv, 1, &pidfile) < 0)        return NULL;    kill_processes_by_pidfile(2, pidfile);    kill_processes_by_pidfile(9, pidfile);    return strdup("t");}

Value* RestoreFn(const char* name, State* state, int argc, Expr* argv[]) {    if (argc < 1) {        return ErrorAbort(state, "%s() expects at least 1 arg", name);    }    char** args = ReadVarArgs(state, argc, argv);    if (args == NULL) {        return NULL;    }    char** args2 = malloc(sizeof(char*) * (argc+1));    memcpy(args2, args, sizeof(char*) * argc);    args2[argc] = NULL;        char* path = strdup(args2[0]);    int restoreboot = 1;    int restoresystem = 1;    int restoredata = 1;    int restorecache = 1;    int restoresdext = 1;    int restorewebtop = 1;    int i;    for (i = 1; i < argc; i++)    {        if (args2[i] == NULL)            continue;        if (strcmp(args2[i], "noboot") == 0)            restoreboot = 0;        else if (strcmp(args2[i], "nosystem") == 0)            restoresystem = 0;        else if (strcmp(args2[i], "nodata") == 0)            restoredata = 0;        else if (strcmp(args2[i], "nocache") == 0)            restorecache = 0;        else if (strcmp(args2[i], "nosd-ext") == 0)            restoresdext = 0;        else if (strcmp(args2[i], "nowebtop") == 0)            restorewebtop = 0;    }        for (i = 0; i < argc; ++i) {        free(args[i]);    }    free(args);    free(args2);    if (0 != nandroid_restore(path, restoreboot, restoresystem, restoredata, restorecache, restoresdext, 0, restorewebtop, 0)) {        free(path);        return StringValue(strdup(""));    }        return StringValue(path);}

Value* SetRadioFn(const char* name, State* state, int argc, Expr* argv[]) {    char *part_type;    if (argc != 1) {        return ErrorAbort(state, "%s() expects arg, got %d", name, argc);    }    char* type = strrchr(name, '_');    if (type == NULL || *(type+1) == '/0') {        return ErrorAbort(state, "%s() couldn't get type from function name",                          name);    }    ++type;    if (ReadArgs(state, argv, 1, &part_type) <0) {        return NULL;    }    start_firmware_update(type,part_type);    return StringValue(strdup(""));}