auto import from //depot/cupcake/@135843

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

commands_recovery_local_path := $(LOCAL_PATH)

ifneq ($(TARGET_SIMULATOR),true)

ifeq ($(TARGET_ARCH),arm)

LOCAL_SRC_FILES := \

	recovery.c \

	bootloader.c \

	commands.c \

	firmware.c \

	install.c \

	roots.c \

	ui.c \

	verifier.c

LOCAL_SRC_FILES += test_roots.c

LOCAL_MODULE := recovery

LOCAL_FORCE_STATIC_EXECUTABLE := true

# This binary is in the recovery ramdisk, which is otherwise a copy of root.

# It gets copied there in config/Makefile.  LOCAL_MODULE_TAGS suppresses

# a (redundant) copy of the binary in /system/bin for user builds.

# TODO: Build the ramdisk image in a more principled way.

LOCAL_MODULE_TAGS := eng

LOCAL_STATIC_LIBRARIES := libminzip libunz libamend libmtdutils libmincrypt

LOCAL_STATIC_LIBRARIES += libminui libpixelflinger_static libcutils

LOCAL_STATIC_LIBRARIES += libstdc++ libc

# Specify a C-includable file containing the OTA public keys.

# This is built in config/Makefile.

# *** THIS IS A TOTAL HACK; EXECUTABLES MUST NOT CHANGE BETWEEN DIFFERENT

#     PRODUCTS/BUILD TYPES. ***

# TODO: make recovery read the keys from an external file.

RECOVERY_INSTALL_OTA_KEYS_INC := \

	$(call intermediates-dir-for,PACKAGING,ota_keys_inc)/keys.inc

# Let install.c say #include "keys.inc"

LOCAL_C_INCLUDES += $(dir $(RECOVERY_INSTALL_OTA_KEYS_INC))

include $(BUILD_EXECUTABLE)

# Depend on the generated keys.inc containing the OTA public keys.

$(intermediates)/install.o: $(RECOVERY_INSTALL_OTA_KEYS_INC)

include $(commands_recovery_local_path)/minui/Android.mk

endif   # TARGET_ARCH == arm

endif	# !TARGET_SIMULATOR

include $(commands_recovery_local_path)/amend/Android.mk

include $(commands_recovery_local_path)/minzip/Android.mk

include $(commands_recovery_local_path)/mtdutils/Android.mk

include $(commands_recovery_local_path)/tools/Android.mk

commands_recovery_local_path :=

# Copyright 2007 The Android Open Source Project

#

LOCAL_PATH := $(call my-dir)

amend_src_files := \

	amend.c \

	lexer.l \

	parser_y.y \

	ast.c \

	symtab.c \

	commands.c \

	permissions.c \

	execute.c

amend_test_files := \

	test_symtab.c \

	test_commands.c \

	test_permissions.c

# "-x c" forces the lex/yacc files to be compiled as c;

# the build system otherwise forces them to be c++.

amend_cflags := -Wall -x c

#

# Build the host-side command line tool

#

include $(CLEAR_VARS)

LOCAL_SRC_FILES := \

		$(amend_src_files) \

		$(amend_test_files) \

		register.c \

		main.c

LOCAL_CFLAGS := $(amend_cflags) -g -O0

LOCAL_MODULE := amend

LOCAL_YACCFLAGS := -v

include $(BUILD_HOST_EXECUTABLE)

#

# Build the device-side library

#

include $(CLEAR_VARS)

LOCAL_SRC_FILES := $(amend_src_files)

LOCAL_SRC_FILES += $(amend_test_files)

LOCAL_CFLAGS := $(amend_cflags)

LOCAL_MODULE := libamend

include $(BUILD_STATIC_LIBRARY)

/*

 * Copyright (C) 2007 The Android Open Source Project

 *

 * 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.

 */

#include <stdlib.h>

#include "amend.h"

#include "lexer.h"

extern const AmCommandList *gCommands;

const AmCommandList *

parseAmendScript(const char *buf, size_t bufLen)

{

    setLexerInputBuffer(buf, bufLen);

    int ret = yyparse();

    if (ret != 0) {

        return NULL;

    }

    return gCommands;

}

/*

 * Copyright (C) 2007 The Android Open Source Project

 *

 * 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.

 */

#ifndef AMEND_H_

#define AMEND_H_

#include "ast.h"

#include "execute.h"

const AmCommandList *parseAmendScript(const char *buf, size_t bufLen);

#endif  // AMEND_H_

/*

 * Copyright (C) 2007 The Android Open Source Project

 *

 * 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.

 */

#include <stdio.h>

#include "ast.h"

static const char gSpaces[] =

    "                                                                "

    "                                                                "

    "                                                                "

    "                                                                "

    "                                                                "

    "                                                                "

    "                                                                ";

const int gSpacesMax = sizeof(gSpaces) - 1;

static const char *

pad(int level)

{

    level *= 4;

    if (level > gSpacesMax) {

        level = gSpacesMax;

    }

    return gSpaces + gSpacesMax - level;

}

void dumpBooleanValue(int level, const AmBooleanValue *booleanValue);

void dumpStringValue(int level, const AmStringValue *stringValue);

void

dumpBooleanExpression(int level, const AmBooleanExpression *booleanExpression)

{

    const char *op;

    bool unary = false;

    switch (booleanExpression->op) {

    case AM_BOP_NOT:

        op = "NOT";

        unary = true;

        break;

    case AM_BOP_EQ:

        op = "EQ";

        break;

    case AM_BOP_NE:

        op = "NE";

        break;

    case AM_BOP_AND:

        op = "AND";

        break;

    case AM_BOP_OR:

        op = "OR";

        break;

    default:

        op = "??";

        break;

    }

    printf("%sBOOLEAN %s {\n", pad(level), op);

    dumpBooleanValue(level + 1, booleanExpression->arg1);

    if (!unary) {

        dumpBooleanValue(level + 1, booleanExpression->arg2);

    }

    printf("%s}\n", pad(level));

}

void

dumpFunctionArguments(int level, const AmFunctionArguments *functionArguments)

{

    int i;

    for (i = 0; i < functionArguments->argc; i++) {

        dumpStringValue(level, &functionArguments->argv[i]);

    }

}

void

dumpFunctionCall(int level, const AmFunctionCall *functionCall)

{

    printf("%sFUNCTION %s (\n", pad(level), functionCall->name);

    dumpFunctionArguments(level + 1, functionCall->args);

    printf("%s)\n", pad(level));

}

void

dumpStringValue(int level, const AmStringValue *stringValue)

{

    switch (stringValue->type) {

    case AM_SVAL_LITERAL:

        printf("%s\"%s\"\n", pad(level), stringValue->u.literal);

        break;

    case AM_SVAL_FUNCTION:

        dumpFunctionCall(level, stringValue->u.function);

        break;

    default:

        printf("%s<UNKNOWN SVAL TYPE %d>\n", pad(level), stringValue->type);

        break;

    }

}

void

dumpStringComparisonExpression(int level,

        const AmStringComparisonExpression *stringComparisonExpression)

{

    const char *op;

    switch (stringComparisonExpression->op) {

    case AM_SOP_LT:

        op = "LT";

        break;

    case AM_SOP_LE:

        op = "LE";

        break;

    case AM_SOP_GT:

        op = "GT";

        break;

    case AM_SOP_GE:

        op = "GE";

        break;

    case AM_SOP_EQ:

        op = "EQ";

        break;

    case AM_SOP_NE:

        op = "NE";

        break;

    default:

        op = "??";

        break;

    }

    printf("%sSTRING %s {\n", pad(level), op);

    dumpStringValue(level + 1, stringComparisonExpression->arg1);

    dumpStringValue(level + 1, stringComparisonExpression->arg2);

    printf("%s}\n", pad(level));

}

void

dumpBooleanValue(int level, const AmBooleanValue *booleanValue)

{

    switch (booleanValue->type) {

    case AM_BVAL_EXPRESSION:

        dumpBooleanExpression(level, &booleanValue->u.expression);

        break;

    case AM_BVAL_STRING_COMPARISON:

        dumpStringComparisonExpression(level,

                &booleanValue->u.stringComparison);

        break;

    default:

        printf("%s<UNKNOWN BVAL TYPE %d>\n", pad(1), booleanValue->type);

        break;

    }

}

void

dumpWordList(const AmWordList *wordList)

{

    int i;

    for (i = 0; i < wordList->argc; i++) {

        printf("%s\"%s\"\n", pad(1), wordList->argv[i]);

    }

}

void

dumpCommandArguments(const AmCommandArguments *commandArguments)

{

    if (commandArguments->booleanArgs) {

        dumpBooleanValue(1, commandArguments->u.b);

    } else {

        dumpWordList(commandArguments->u.w);

    }

}

void

dumpCommand(const AmCommand *command)

{

    printf("command \"%s\" {\n", command->name);

    dumpCommandArguments(command->args);

    printf("}\n");

}

void

dumpCommandList(const AmCommandList *commandList)

{

    int i;

    for (i = 0; i < commandList->commandCount; i++) {

        dumpCommand(commandList->commands[i]);

    }

}