void CLockBox9::on_add_node_child(StateDataNode* parent, StateDataNode* child) {
if(child->get_id().name == NAME_LOCKBOX) {
/** @todo Perhaps it's necessary to copy volume DATA to lock DATA, depending on the flags.
Without this, if application only modifies a region of lock DATA
the contents of the surface DATA corresponding to a non modified regions
of lock DATA are overwritten with zeroes.
*/
// Calculate size of DATA node and resize it
D3DFORMAT format;
child->get_parent()->get_child(StateId(NAME_FORMAT))->read_data(&format);
UINT left, right, top, bottom, front, back;
child->get_child(StateId(NAME_LEFT))->read_data(&left);
child->get_child(StateId(NAME_RIGHT))->read_data(&right);
child->get_child(StateId(NAME_TOP))->read_data(&top);
child->get_child(StateId(NAME_BOTTOM))->read_data(&bottom);
child->get_child(StateId(NAME_TOP))->read_data(&front);
child->get_child(StateId(NAME_BOTTOM))->read_data(&back);
UINT width = right - left;
UINT height = bottom - top;
UINT depth = back - front;
// Change units for compressed formats
/// @note Depth is not affected
if(is_compressed(format)) {
width = width / 4 + (((width % 4) == 0) ? 0 : 1);
height = height / 4 + (((height % 4) == 0) ? 0 : 1);
}
UINT size = depth * width * height * texel_size(format);
child->get_child(StateId(NAME_DATA))->set_data_size(size);
D3D_DEBUG( cout << "CLOCKBOX9: Resizing SLOCKBOX DATA to " << (int)size << endl; )
int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
grpc_byte_buffer *buffer) {
grpc_slice_buffer decompressed_slices_buffer;
reader->buffer_in = buffer;
switch (reader->buffer_in->type) {
case GRPC_BB_RAW:
grpc_slice_buffer_init(&decompressed_slices_buffer);
if (is_compressed(reader->buffer_in)) {
if (grpc_msg_decompress(reader->buffer_in->data.raw.compression,
&reader->buffer_in->data.raw.slice_buffer,
&decompressed_slices_buffer) == 0) {
gpr_log(GPR_ERROR,
"Unexpected error decompressing data for algorithm with enum "
"value '%d'.",
reader->buffer_in->data.raw.compression);
memset(reader, 0, sizeof(*reader));
return 0;
} else { /* all fine */
reader->buffer_out =
grpc_raw_byte_buffer_create(decompressed_slices_buffer.slices,
decompressed_slices_buffer.count);
}
grpc_slice_buffer_destroy(&decompressed_slices_buffer);
} else { /* not compressed, use the input buffer as output */
reader->buffer_out = reader->buffer_in;
}
reader->current.index = 0;
break;
}
return 1;
}
char *file_uncompress(char *filename)
{
static char newfile[MAXFNAMELEN];
char command[BUFSIZ], *ptr, *suffix = NULL;
/* Filename to be returned */
strcpy(newfile, filename);
/* Uncompress depending on compression method */
if(is_gzipped(filename)) {
if(!env_inpath("gunzip"))
return(NULL);
sprintf(command, "gunzip -f %s", filename);
if(!system(command))
return(NULL);
suffix = ".gz";
}
else if(is_compressed(filename)) {
if(!env_inpath("uncompress"))
return(NULL);
sprintf(command, "uncompress -f %s", filename);
if(!system(command))
return(NULL);
suffix = ".Z";
}
/* Strip of suffix if it was there */
if(suffix != NULL) {
if((ptr = strstr(newfile, suffix)) != NULL)
*ptr = 0;
}
/* Return uncomprssed filename */
return(newfile);
}
void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader) {
switch (reader->buffer_in->type) {
case GRPC_BB_RAW:
/* keeping the same if-else structure as in the init function */
if (is_compressed(reader->buffer_in)) {
grpc_byte_buffer_destroy(reader->buffer_out);
}
break;
}
}
void grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
grpc_byte_buffer *buffer) {
gpr_slice_buffer decompressed_slices_buffer;
reader->buffer_in = buffer;
switch (reader->buffer_in->type) {
case GRPC_BB_RAW:
gpr_slice_buffer_init(&decompressed_slices_buffer);
if (is_compressed(reader->buffer_in)) {
grpc_msg_decompress(reader->buffer_in->data.raw.compression,
&reader->buffer_in->data.raw.slice_buffer,
&decompressed_slices_buffer);
reader->buffer_out =
grpc_raw_byte_buffer_create(decompressed_slices_buffer.slices,
decompressed_slices_buffer.count);
gpr_slice_buffer_destroy(&decompressed_slices_buffer);
} else { /* not compressed, use the input buffer as output */
reader->buffer_out = reader->buffer_in;
}
reader->current.index = 0;
break;
}
}
/**
* @internal
*/
static void update_progress_counters(winx_file_info *f,udefrag_job_parameters *jp)
{
ULONGLONG filesize;
jp->pi.files ++;
if(is_directory(f)) jp->pi.directories ++;
if(is_compressed(f)) jp->pi.compressed ++;
jp->pi.processed_clusters += f->disp.clusters;
filesize = f->disp.clusters * jp->v_info.bytes_per_cluster;
if(filesize >= GIANT_FILE_SIZE)
jp->f_counters.giant_files ++;
else if(filesize >= HUGE_FILE_SIZE)
jp->f_counters.huge_files ++;
else if(filesize >= BIG_FILE_SIZE)
jp->f_counters.big_files ++;
else if(filesize >= AVERAGE_FILE_SIZE)
jp->f_counters.average_files ++;
else if(filesize >= SMALL_FILE_SIZE)
jp->f_counters.small_files ++;
else
jp->f_counters.tiny_files ++;
}
int main(int argc, char **argv)
{
header_keys keys;
u8 rawkheaderBk[0x90];
if(argc < 2)
{
printf("USAGE: PrxEncrypter [prx]\n");
return 0;
}
memset(in_buffer, 0, sizeof(in_buffer));
memset(out_buffer, 0, sizeof(out_buffer));
memset(kirk_raw, 0, sizeof(kirk_raw));
memset(kirk_enc, 0, sizeof(kirk_enc));
memset(elf, 0, sizeof(elf));
kirk_init();
int elfSize = load_elf(argv[1]);
if(elfSize < 0) {
printf("Cannot open %s\n", argv[1]);
return 0;
}
Header_List *target_header = get_header_list( elfSize );
if( target_header == NULL ) {
printf("PRX SIGNER: Elf is to big\n");
return 0;
}
u8 *kirkHeader = target_header->kirkHeader;
u8 *pspHeader = target_header->pspHeader;
int krawSize = get_kirk_size(kirkHeader);
if (is_compressed(pspHeader)) {
elfSize = get_elf_size(pspHeader);
gzip_compress(elf, elf, elfSize);
}
memcpy(kirk_raw, kirkHeader, 0x110);
memcpy(rawkheaderBk, kirk_raw, sizeof(rawkheaderBk));
kirk_decrypt_keys((u8*)&keys, kirk_raw);
memcpy(kirk_raw, &keys, sizeof(header_keys));
memcpy(kirk_raw+0x110, elf, elfSize);
if(kirk_CMD0(kirk_enc, kirk_raw, sizeof(kirk_enc), 0) != 0)
{
printf("PRX SIGNER: Could not encrypt elf\n");
return 0;
}
memcpy(kirk_enc, rawkheaderBk, sizeof(rawkheaderBk));
if(kirk_forge(kirk_enc, sizeof(kirk_enc)) != 0)
{
printf("PRX SIGNER: Could not forge cmac block\n");
return 0;
}
memcpy(out_buffer, pspHeader, 0x150);
memcpy(out_buffer+0x150, kirk_enc+0x110, krawSize-0x110);
return dumpFile("./data.psp", out_buffer, (krawSize-0x110)+0x150);
}
bool mvt_tile::decode(std::string &message) {
layers.clear();
std::string src;
if (is_compressed(message)) {
std::string uncompressed;
decompress(message, uncompressed);
src = uncompressed;
} else {
src = message;
}
protozero::pbf_reader reader(src);
while (reader.next()) {
switch (reader.tag()) {
case 3: /* layer */
{
protozero::pbf_reader layer_reader(reader.get_message());
mvt_layer layer;
while (layer_reader.next()) {
switch (layer_reader.tag()) {
case 1: /* name */
layer.name = layer_reader.get_string();
break;
case 3: /* key */
layer.keys.push_back(layer_reader.get_string());
break;
case 4: /* value */
{
protozero::pbf_reader value_reader(layer_reader.get_message());
mvt_value value;
while (value_reader.next()) {
switch (value_reader.tag()) {
case 1: /* string */
value.type = mvt_string;
value.string_value = value_reader.get_string();
break;
case 2: /* float */
value.type = mvt_float;
value.numeric_value.float_value = value_reader.get_float();
break;
case 3: /* double */
value.type = mvt_double;
value.numeric_value.double_value = value_reader.get_double();
break;
case 4: /* int */
value.type = mvt_int;
value.numeric_value.int_value = value_reader.get_int64();
break;
case 5: /* uint */
value.type = mvt_uint;
value.numeric_value.uint_value = value_reader.get_uint64();
break;
case 6: /* sint */
value.type = mvt_sint;
value.numeric_value.sint_value = value_reader.get_sint64();
break;
case 7: /* bool */
value.type = mvt_bool;
value.numeric_value.bool_value = value_reader.get_bool();
break;
default:
value_reader.skip();
break;
}
}
layer.values.push_back(value);
break;
}
case 5: /* extent */
layer.extent = layer_reader.get_uint32();
break;
case 2: /* feature */
{
protozero::pbf_reader feature_reader(layer_reader.get_message());
mvt_feature feature;
std::vector<uint32_t> geoms;
while (feature_reader.next()) {
switch (feature_reader.tag()) {
case 2: /* tag */
{
auto pi = feature_reader.get_packed_uint32();
for (auto it = pi.first; it != pi.second; ++it) {
feature.tags.push_back(*it);
}
break;
}
case 3: /* feature type */
feature.type = feature_reader.get_enum();
break;
case 4: /* geometry */
{
auto pi = feature_reader.get_packed_uint32();
for (auto it = pi.first; it != pi.second; ++it) {
geoms.push_back(*it);
}
break;
}
default:
feature_reader.skip();
break;
}
}
long long px = 0, py = 0;
for (size_t g = 0; g < geoms.size(); g++) {
uint32_t geom = geoms[g];
uint32_t op = geom & 7;
uint32_t count = geom >> 3;
if (op == mvt_moveto || op == mvt_lineto) {
for (size_t k = 0; k < count && g + 2 < geoms.size(); k++) {
px += protozero::decode_zigzag32(geoms[g + 1]);
py += protozero::decode_zigzag32(geoms[g + 2]);
g += 2;
feature.geometry.push_back(mvt_geometry(op, px, py));
}
} else {
feature.geometry.push_back(mvt_geometry(op, 0, 0));
}
}
layer.features.push_back(feature);
break;
}
default:
layer_reader.skip();
break;
}
}
for (size_t i = 0; i < layer.keys.size(); i++) {
layer.key_map.insert(std::pair<std::string, size_t>(layer.keys[i], i));
}
for (size_t i = 0; i < layer.values.size(); i++) {
layer.value_map.insert(std::pair<mvt_value, size_t>(layer.values[i], i));
}
layers.push_back(layer);
break;
}
default:
reader.skip();
break;
}
}
return true;
}
bool ktx_texture::operator==(const ktx_texture &rhs) const
{
if (this == &rhs)
return true;
// This is not super deep because I want to avoid poking around into internal state (such as the header)
#define CMP(x) \
if (x != rhs.x) \
return false;
CMP(get_ogl_internal_fmt());
CMP(get_width());
CMP(get_height());
CMP(get_depth());
CMP(get_num_mips());
CMP(get_array_size());
CMP(get_num_faces());
CMP(is_compressed());
CMP(get_block_dim());
// The image fmt/type shouldn't matter with compressed textures.
if (!is_compressed())
{
CMP(get_ogl_fmt());
CMP(get_ogl_type());
}
CMP(get_total_images());
CMP(get_opposite_endianness());
// Do an order insensitive key/value comparison.
dynamic_string_array lhs_keys;
get_keys(lhs_keys);
dynamic_string_array rhs_keys;
rhs.get_keys(rhs_keys);
if (lhs_keys.size() != rhs_keys.size())
return false;
lhs_keys.sort(dynamic_string_less_than_case_sensitive());
rhs_keys.sort(dynamic_string_less_than_case_sensitive());
for (uint32_t i = 0; i < lhs_keys.size(); i++)
if (lhs_keys[i].compare(rhs_keys[i], true) != 0)
return false;
for (uint32_t i = 0; i < lhs_keys.size(); i++)
{
uint8_vec lhs_data, rhs_data;
if (!get_key_value_data(lhs_keys[i].get_ptr(), lhs_data))
return false;
if (!get_key_value_data(lhs_keys[i].get_ptr(), rhs_data))
return false;
if (lhs_data != rhs_data)
return false;
}
// Compare images.
for (uint32_t l = 0; l < get_num_mips(); l++)
{
for (uint32_t a = 0; a < get_array_size(); a++)
{
for (uint32_t f = 0; f < get_num_faces(); f++)
{
for (uint32_t z = 0; z < get_depth(); z++)
{
const uint8_vec &lhs_img = get_image_data(l, a, f, z);
const uint8_vec &rhs_img = rhs.get_image_data(l, a, f, z);
if (lhs_img != rhs_img)
return false;
}
}
}
}
#undef CMP
return true;
}
int transform(const char *fpath, const struct stat *sb, int typeflag, struct FTW* ftwbuf)
{
int compress_type;
int fd_s, fd_t;
struct stat stbuf_s;
struct utimbuf utime_s;
char *tmpname;
off_t size;
compressor_t *decomp;
if (typeflag != FTW_F || !S_ISREG(sb->st_mode))
return 0;
/* internal file (attribute file, dedup DB) */
if (strncmp(&fpath[ftwbuf->base], FUSECOMPRESS_PREFIX, sizeof(FUSECOMPRESS_PREFIX) - 1) == 0)
return 0;
if (verbose)
fprintf(stderr, "%s: ", fpath);
if (comp && !is_compressible(&fpath[ftwbuf->base])) {
if (verbose)
fprintf(stderr, "incompressible\n");
return 0;
}
compress_type = is_compressed(fpath);
if (compress_type < -1)
{
fprintf(stderr, "failed to check %s for compression status\n", fpath);
errors++;
return 0;
}
/* if this is the type we are supposed to recompress, decompress
it first */
if (comp && recomp && compress_type == recomp->type) {
compressor_t *temp_c = comp;
int temp_v = verbose;
comp = NULL;
if (verbose)
fprintf(stderr, "recompress ");
verbose = 0;
transform(fpath, sb, typeflag, ftwbuf);
verbose = temp_v;
comp = temp_c;
compress_type = -1;
}
if (comp && compress_type >= 0)
{
if (verbose)
fprintf(stderr, "compressed already\n");
return 0;
}
if (!comp && compress_type < 0)
{
if (verbose)
fprintf(stderr, "uncompressed already\n");
return 0;
}
fd_s = file_open(fpath, O_RDONLY);
if (fstat(fd_s, &stbuf_s) < 0)
{
perror("unable to fstat");
return -1;
}
tmpname = file_create_temp(&fd_t);
current_tmp_file = tmpname;
if (!tmpname)
{
fprintf(stderr, "unable to create temporary file for compression\n");
return -1;
}
if (comp)
{
if (lseek(fd_t, sizeof(header_t), SEEK_SET) < 0)
{
perror("failed to seek beyond header");
goto out;
}
size = comp->compress(NULL, fd_s, fd_t);
if (lseek(fd_t, 0, SEEK_SET) < 0)
{
perror("failed to seek to beginning");
goto out;
}
if (file_write_header(fd_t, comp, stbuf_s.st_size) < 0)
{
perror("failed to write header");
goto out;
}
}
else
{
if (file_read_header_fd(fd_s, &decomp, &size) < 0)
{
perror("unable to read header");
goto out;
}
size = decomp->decompress(fd_s, fd_t);
}
if (size == (off_t) - 1)
{
fprintf(stderr, "compression failed\n");
goto out;
}
close(fd_s);
close(fd_t);
if (rename(tmpname, fpath) < 0)
{
perror("failed to rename tempfile");
goto out;
}
current_tmp_file = NULL;
if (lchown(fpath, stbuf_s.st_uid, stbuf_s.st_gid) < 0)
{
perror("unable to set owner/group");
/* do not abort; the filesystem may not support this */
}
if (chmod(fpath, stbuf_s.st_mode) < 0)
{
perror("unable to set permissions");
/* do not abort; the filesystem may not support this */
}
utime_s.actime = stbuf_s.st_atime;
utime_s.modtime = stbuf_s.st_mtime;
if (utime(fpath, &utime_s) < 0)
{
perror("failed to set timestamps");
goto out;
}
if (verbose)
fprintf(stderr, "ok\n");
return 0;
out:
close(fd_s);
close(fd_t);
unlink(tmpname);
return -1;
}
jushort start_pc(int index) {
GUARANTEE(((index * 3) + 1) < length(),
"local var table: start_pc index out of range");
return is_compressed() ? ubyte_at((index * 3) + 1) :
ushort_at((index * 3) + 1);
}
jushort line_number(int index) {
GUARANTEE(((index * 2) + 1) < length(),
"line number table line_num index out of bounds");
return is_compressed() ? ubyte_at((index * 2) + 1) :
short_at((index * 2) + 1);
}
jushort pc(int index) {
GUARANTEE((index * 2) < length(),
"line number table pc index out of bounds");
return is_compressed() ? ubyte_at(index * 2) :
ushort_at(index * 2);
}
jushort slot(int index) {
GUARANTEE((index * 3) < length(),
"local var table: slot index out of range");
return is_compressed() ? ubyte_at(index * 3) :
ushort_at(index * 3);
}
//проверка является ли формат несжатым
bool is_uncompressed (PixelFormat format)
{
return !is_compressed (format);
}
static int save_lua_report(udefrag_job_parameters *jp)
{
wchar_t *path = NULL;
WINX_FILE *f;
wchar_t *cn;
wchar_t compname[MAX_COMPUTERNAME_LENGTH + 1];
char utf8_compname[(MAX_COMPUTERNAME_LENGTH + 1) * 4];
char buffer[512];
struct prb_traverser t;
winx_file_info *file;
char *comment;
char *status;
int length;
winx_time tm;
/* should be enough for any path in UTF-8 encoding */
#define MAX_UTF8_PATH_LENGTH (256 * 1024)
char *utf8_path;
utf8_path = winx_tmalloc(MAX_UTF8_PATH_LENGTH);
if(utf8_path == NULL){
mtrace();
return (-1);
}
path = get_report_path(jp);
if(path == NULL)
return UDEFRAG_NO_MEM;
f = winx_fbopen(path,"w",RSB_SIZE);
if(f == NULL){
f = winx_fopen(path,"w");
if(f == NULL){
winx_free(path);
winx_free(utf8_path);
return (-1);
}
}
/* print header */
cn = winx_getenv(L"COMPUTERNAME");
if(cn){
wcsncpy(compname,cn,MAX_COMPUTERNAME_LENGTH + 1);
compname[MAX_COMPUTERNAME_LENGTH] = 0;
winx_free(cn);
} else {
wcscpy(compname,L"nil");
}
winx_to_utf8(utf8_compname,sizeof(utf8_compname),compname);
memset(&tm,0,sizeof(winx_time));
(void)winx_get_local_time(&tm);
(void)_snprintf(buffer,sizeof(buffer),
"-- UltraDefrag report for disk %c:\r\n\r\n"
"format_version = 7\r\n\r\n"
"volume_letter = \"%c\"\r\n"
"computer_name = \"%hs\"\r\n\r\n"
"current_time = {\r\n"
"\tyear = %04i,\r\n"
"\tmonth = %02i,\r\n"
"\tday = %02i,\r\n"
"\thour = %02i,\r\n"
"\tmin = %02i,\r\n"
"\tsec = %02i,\r\n"
"\tisdst = false\r\n"
"}\r\n\r\n"
"files = {\r\n",
jp->volume_letter, jp->volume_letter,utf8_compname,
(int)tm.year,(int)tm.month,(int)tm.day,
(int)tm.hour,(int)tm.minute,(int)tm.second
);
buffer[sizeof(buffer) - 1] = 0;
(void)winx_fwrite(buffer,1,strlen(buffer),f);
/* print body */
prb_t_init(&t,jp->fragmented_files);
file = prb_t_first(&t,jp->fragmented_files);
while(file){
if(is_directory(file))
comment = "[DIR]";
else if(is_compressed(file))
comment = "[CMP]";
else
comment = " - ";
/*
* On change of status strings don't forget
* also to adjust write_file_status routine
* in udreportcnv.lua file.
*/
if(is_locked(file))
status = "locked";
else if(is_moving_failed(file))
status = "move failed";
else if(is_in_improper_state(file))
status = "invalid";
else
status = " - ";
(void)_snprintf(buffer, sizeof(buffer),
"\t{fragments = %u,"
"size = %I64u,"
"comment = \"%s\","
"status = \"%s\","
"path = \"",
(UINT)file->disp.fragments,
file->disp.clusters * jp->v_info.bytes_per_cluster,
comment,
status
);
buffer[sizeof(buffer) - 1] = 0;
(void)winx_fwrite(buffer,1,strlen(buffer),f);
if(file->path != NULL){
/* skip \??\ sequence in the beginning of the path */
length = (int)wcslen(file->path);
if(length > 4){
convert_to_utf8_path(utf8_path,MAX_UTF8_PATH_LENGTH,file->path + 4);
} else {
convert_to_utf8_path(utf8_path,MAX_UTF8_PATH_LENGTH,file->path);
}
(void)winx_fwrite(utf8_path,1,strlen(utf8_path),f);
}
(void)strcpy(buffer,"\"},\r\n");
(void)winx_fwrite(buffer,1,strlen(buffer),f);
file = prb_t_next(&t);
}
/* print footer */
(void)strcpy(buffer,"}\r\n");
(void)winx_fwrite(buffer,1,strlen(buffer),f);
itrace("report saved to %ws",path);
winx_fclose(f);
winx_free(path);
winx_free(utf8_path);
return 0;
}
jushort code_length(int index) {
GUARANTEE(((index * 3) + 2) < length(),
"local var table: code_length index out of range");
return is_compressed() ? ubyte_at((index * 3) + 2) :
ushort_at((index * 3) + 2);
}