blob: bf6c925fedd9dac3d7dd2b91e89e9ed14dda2058 [file] [log] [blame]
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COURGETTE_COURGETTE_H_
#define COURGETTE_COURGETTE_H_
#include <stddef.h> // Required to define size_t on GCC
#include "base/files/file_path.h"
namespace courgette {
// Status codes for Courgette APIs.
//
// Client code should only rely on the distintion between C_OK and the other
// status codes.
//
enum Status {
C_OK = 1, // Successful operation.
C_GENERAL_ERROR = 2, // Error other than listed below.
C_READ_OPEN_ERROR = 3, // Could not open input file for reading.
C_READ_ERROR = 4, // Could not read from opened input file.
C_WRITE_OPEN_ERROR = 3, // Could not open output file for writing.
C_WRITE_ERROR = 4, // Could not write to opened output file.
C_BAD_ENSEMBLE_MAGIC = 5, // Ensemble patch has bad magic.
C_BAD_ENSEMBLE_VERSION = 6, // Ensemble patch has wrong version.
C_BAD_ENSEMBLE_HEADER = 7, // Ensemble patch has corrupt header.
C_BAD_ENSEMBLE_CRC = 8, // Ensemble patch has corrupt data.
C_BAD_TRANSFORM = 12, // Transform mis-specified.
C_BAD_BASE = 13, // Base for transform malformed.
C_BINARY_DIFF_CRC_ERROR = 14, // Internal diff input doesn't have expected
// CRC.
// Internal errors.
C_STREAM_ERROR = 20, // Unexpected error from streams.h.
C_STREAM_NOT_CONSUMED = 21, // Stream has extra data, is expected to be
// used up.
C_SERIALIZATION_FAILED = 22, //
C_DESERIALIZATION_FAILED = 23, //
C_INPUT_NOT_RECOGNIZED = 24, // Unrecognized input (not an executable).
C_DISASSEMBLY_FAILED = 25, //
C_ASSEMBLY_FAILED = 26, //
C_ADJUSTMENT_FAILED = 27, //
C_TRIM_FAILED = 28, // TrimLabels failed
};
// What type of executable is something
// This is part of the patch format. Never reuse an id number.
enum ExecutableType {
EXE_UNKNOWN = 0,
EXE_WIN_32_X86 = 1,
EXE_ELF_32_X86 = 2,
EXE_ELF_32_ARM = 3,
EXE_WIN_32_X64 = 4,
};
class SinkStream;
class SinkStreamSet;
class SourceStream;
class SourceStreamSet;
class AssemblyProgram;
class EncodedProgram;
// Applies the patch to the bytes in |old| and writes the transformed ensemble
// to |output|.
// Returns C_OK unless something went wrong.
Status ApplyEnsemblePatch(SourceStream* old, SourceStream* patch,
SinkStream* output);
// Applies the patch in |patch_file_name| to the bytes in |old_file_name| and
// writes the transformed ensemble to |new_file_name|.
// Returns C_OK unless something went wrong.
// This function first validates that the patch file has a proper header, so the
// function can be used to 'try' a patch.
Status ApplyEnsemblePatch(const base::FilePath::CharType* old_file_name,
const base::FilePath::CharType* patch_file_name,
const base::FilePath::CharType* new_file_name);
// Generates a patch that will transform the bytes in |old| into the bytes in
// |target|.
// Returns C_OK unless something when wrong (unexpected).
Status GenerateEnsemblePatch(SourceStream* old, SourceStream* target,
SinkStream* patch);
// Detects the type of an executable file, and it's length. The length
// may be slightly smaller than some executables (like ELF), but will include
// all bytes the courgette algorithm has special benefit for.
// On sucess:
// Fill in type and detected_length, and return C_OK.
// On failure:
// Fill in type with UNKNOWN, detected_length with 0, and
// return C_INPUT_NOT_RECOGNIZED
Status DetectExecutableType(const void* buffer, size_t length,
ExecutableType* type,
size_t* detected_length);
// Attempts to detect the type of executable, and parse it with the
// appropriate tools, storing the pointer to the AssemblyProgram in |*output|.
// Returns C_OK if successful, otherwise returns an error status and sets
// |*output| to NULL.
Status ParseDetectedExecutable(const void* buffer, size_t length,
AssemblyProgram** output);
// Trims labels used fewer than a given number of times from an
// assembly program in-place.
Status TrimLabels(AssemblyProgram* program);
// Converts |program| into encoded form, returning it as |*output|.
// Returns C_OK if succeeded, otherwise returns an error status and
// sets |*output| to NULL
Status Encode(AssemblyProgram* program, EncodedProgram** output);
// Serializes |encoded| into the stream set.
// Returns C_OK if succeeded, otherwise returns an error status.
Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink);
// Assembles |encoded|, emitting the bytes into |buffer|.
// Returns C_OK if succeeded, otherwise returns an error status and leaves
// |buffer| in an undefined state.
Status Assemble(EncodedProgram* encoded, SinkStream* buffer);
// Deserializes program from the stream set.
// Returns C_OK if succeeded, otherwise returns an error status and
// sets |*output| to NULL
Status ReadEncodedProgram(SourceStreamSet* source, EncodedProgram** output);
// Used to free an AssemblyProgram returned by other APIs.
void DeleteAssemblyProgram(AssemblyProgram* program);
// Used to free an EncodedProgram returned by other APIs.
void DeleteEncodedProgram(EncodedProgram* encoded);
// Adjusts |program| to look more like |model|.
//
Status Adjust(const AssemblyProgram& model, AssemblyProgram *program);
} // namespace courgette
#endif // COURGETTE_COURGETTE_H_