plist_t tss_request_new(plist_t overrides) { plist_t request = plist_new_dict(); plist_dict_set_item(request, "@Locality", plist_new_string("en_US")); plist_dict_set_item(request, "@HostPlatformInfo", #ifdef WIN32 plist_new_string("windows") #else plist_new_string("mac") #endif ); plist_dict_set_item(request, "@VersionInfo", plist_new_string(TSS_CLIENT_VERSION_STRING)); char* guid = generate_guid(); if (guid) { plist_dict_set_item(request, "@UUID", plist_new_string(guid)); free(guid); } /* apply overrides */ if (overrides) { plist_dict_merge(&request, overrides); } return request; }
void CGameGraphBuilder::create_graph (const float &start, const float &amount) { Progress (start); VERIFY (!m_graph); m_graph = xr_new<graph_type>(); m_graph_guid = generate_guid(); Progress (start + amount); }
void xrSaveNodes(LPCSTR N, LPCSTR out_name) { Msg ("NS: %d, CNS: %d, ratio: %f%%",sizeof(vertex),sizeof(CLevelGraph::CVertex),100*float(sizeof(CLevelGraph::CVertex))/float(sizeof(vertex))); Msg ("Renumbering nodes..."); string_path fName; strconcat (sizeof(fName),fName,N,out_name); IWriter *fs = FS.w_open(fName); // Header Status ("Saving header..."); hdrNODES H; H.version = XRAI_CURRENT_VERSION; H.count = g_nodes.size(); H.size = g_params.fPatchSize; H.size_y = CalculateHeight(H.aabb); H.guid = generate_guid(); fs->w (&H,sizeof(H)); // fs->w_u32 (g_covers_palette.size()); // for (u32 j=0; j<g_covers_palette.size(); ++j) // fs->w (&g_covers_palette[j],sizeof(g_covers_palette[j])); // All nodes Status ("Saving nodes..."); for (u32 i=0; i<g_nodes.size(); ++i) { vertex &N = g_nodes[i]; NodeCompressed NC; Compress (NC,N,H); compressed_nodes.push_back(NC); } xr_vector<u32> sorted; xr_vector<u32> renumbering; CNodeRenumberer A(compressed_nodes,sorted,renumbering); for (u32 i=0; i<g_nodes.size(); ++i) { fs->w (&compressed_nodes[i],sizeof(NodeCompressed)); Progress (float(i)/float(g_nodes.size())); } // Stats u32 SizeTotal = fs->tell(); Msg ("%dK saved",SizeTotal/1024); FS.w_close (fs); }
/* API function documented in wimlib.h */ WIMLIBAPI int wimlib_create_new_wim(enum wimlib_compression_type ctype, WIMStruct **wim_ret) { int ret; WIMStruct *wim; ret = wimlib_global_init(WIMLIB_INIT_FLAG_ASSUME_UTF8); if (ret) return ret; if (!wim_ret) return WIMLIB_ERR_INVALID_PARAM; if (!wim_compression_type_valid(ctype)) return WIMLIB_ERR_INVALID_COMPRESSION_TYPE; wim = new_wim_struct(); if (!wim) return WIMLIB_ERR_NOMEM; wim->blob_table = new_blob_table(9001); if (!wim->blob_table) { wimlib_free(wim); return WIMLIB_ERR_NOMEM; } /* Fill in wim->hdr with default values */ wim->hdr.magic = WIM_MAGIC; wim->hdr.wim_version = WIM_VERSION_DEFAULT; wim->hdr.flags = 0; wim->hdr.chunk_size = 0; generate_guid(wim->hdr.guid); wim->hdr.part_number = 1; wim->hdr.total_parts = 1; wim->hdr.image_count = 0; wim->hdr.boot_idx = 0; wim->compression_type = WIMLIB_COMPRESSION_TYPE_NONE; wim->chunk_size = wim->hdr.chunk_size; /* Set the output compression type */ wim->out_compression_type = ctype; wim->out_chunk_size = wim_default_nonsolid_chunk_size(ctype); *wim_ret = wim; return 0; }
void CGameSpawnConstructor::save_spawn (LPCSTR name, LPCSTR output) { CMemoryWriter stream; m_spawn_header.m_version = XRAI_CURRENT_VERSION; m_spawn_header.m_guid = generate_guid(); m_spawn_header.m_graph_guid = game_graph().header().guid(); m_spawn_header.m_spawn_count = spawn_graph().vertex_count(); m_spawn_header.m_level_count = (u32)m_level_spawns.size(); stream.open_chunk (0); stream.w_u32 (m_spawn_header.m_version); save_data (m_spawn_header.m_guid,stream); save_data (m_spawn_header.m_graph_guid,stream); stream.w_u32 (m_spawn_header.m_spawn_count); stream.w_u32 (m_spawn_header.m_level_count); stream.close_chunk (); stream.open_chunk (1); save_data (spawn_graph(),stream); stream.close_chunk (); stream.open_chunk (2); save_data (m_level_points,stream); stream.close_chunk (); stream.open_chunk (3); save_data (m_patrol_path_storage,stream); stream.close_chunk (); stream.open_chunk (4); m_game_graph->save (stream); stream.close_chunk (); stream.save_to (*spawn_name(output)); }
plist_t tss_create_request(plist_t build_identity, uint64_t ecid, unsigned char* nonce, int nonce_size) { uint64_t unique_build_size = 0; char* unique_build_data = NULL; plist_t unique_build_node = plist_dict_get_item(build_identity, "UniqueBuildID"); if (!unique_build_node || plist_get_node_type(unique_build_node) != PLIST_DATA) { error("ERROR: Unable to find UniqueBuildID node\n"); return NULL; } plist_get_data_val(unique_build_node, &unique_build_data, &unique_build_size); int chip_id = 0; char* chip_id_string = NULL; plist_t chip_id_node = plist_dict_get_item(build_identity, "ApChipID"); if (!chip_id_node || plist_get_node_type(chip_id_node) != PLIST_STRING) { error("ERROR: Unable to find ApChipID node\n"); return NULL; } plist_get_string_val(chip_id_node, &chip_id_string); sscanf(chip_id_string, "%x", &chip_id); int board_id = 0; char* board_id_string = NULL; plist_t board_id_node = plist_dict_get_item(build_identity, "ApBoardID"); if (!board_id_node || plist_get_node_type(board_id_node) != PLIST_STRING) { error("ERROR: Unable to find ApBoardID node\n"); return NULL; } plist_get_string_val(board_id_node, &board_id_string); sscanf(board_id_string, "%x", &board_id); int security_domain = 0; char* security_domain_string = NULL; plist_t security_domain_node = plist_dict_get_item(build_identity, "ApSecurityDomain"); if (!security_domain_node || plist_get_node_type(security_domain_node) != PLIST_STRING) { error("ERROR: Unable to find ApSecurityDomain node\n"); return NULL; } plist_get_string_val(security_domain_node, &security_domain_string); sscanf(security_domain_string, "%x", &security_domain); char ecid_string[ECID_STRSIZE]; memset(ecid_string, '\0', ECID_STRSIZE); if (ecid == 0) { error("ERROR: Unable to get ECID\n"); return NULL; } snprintf(ecid_string, ECID_STRSIZE, FMT_qu, (long long unsigned int)ecid); // Add build information to TSS request plist_t tss_request = plist_new_dict(); plist_dict_insert_item(tss_request, "@APTicket", plist_new_bool(1)); plist_dict_insert_item(tss_request, "@BBTicket", plist_new_bool(1)); plist_dict_insert_item(tss_request, "@HostIpAddress", plist_new_string("192.168.0.1")); plist_dict_insert_item(tss_request, "@HostPlatformInfo", plist_new_string("mac")); plist_dict_insert_item(tss_request, "@Locality", plist_new_string("en_US")); char* guid = generate_guid(); if (guid) { plist_dict_insert_item(tss_request, "@UUID", plist_new_string(guid)); free(guid); } plist_dict_insert_item(tss_request, "@VersionInfo", plist_new_string("libauthinstall-107.3")); plist_dict_insert_item(tss_request, "ApBoardID", plist_new_uint(board_id)); plist_dict_insert_item(tss_request, "ApChipID", plist_new_uint(chip_id)); plist_dict_insert_item(tss_request, "ApECID", plist_new_string(ecid_string)); if (nonce && (nonce_size > 0)) { plist_dict_insert_item(tss_request, "ApNonce", plist_new_data(nonce, nonce_size)); } plist_dict_insert_item(tss_request, "ApProductionMode", plist_new_bool(1)); plist_dict_insert_item(tss_request, "ApSecurityDomain", plist_new_uint(security_domain)); plist_dict_insert_item(tss_request, "UniqueBuildID", plist_new_data(unique_build_data, unique_build_size)); free(unique_build_data); // Add all firmware files to TSS request plist_t manifest_node = plist_dict_get_item(build_identity, "Manifest"); if (!manifest_node || plist_get_node_type(manifest_node) != PLIST_DICT) { error("ERROR: Unable to find restore manifest\n"); plist_free(tss_request); return NULL; } char* key = NULL; plist_t manifest_entry = NULL; plist_dict_iter iter = NULL; plist_dict_new_iter(manifest_node, &iter); while (1) { plist_dict_next_item(manifest_node, iter, &key, &manifest_entry); if (key == NULL) break; if (!manifest_entry || plist_get_node_type(manifest_entry) != PLIST_DICT) { error("ERROR: Unable to fetch BuildManifest entry\n"); free(tss_request); return NULL; } if (strcmp(key, "BasebandFirmware") == 0) { free(key); continue; } plist_t tss_entry = plist_copy(manifest_entry); plist_dict_insert_item(tss_request, key, tss_entry); free(key); } if (idevicerestore_debug) { debug_plist(tss_request); } return tss_request; }
static int write_split_wim(WIMStruct *orig_wim, const tchar *swm_name, struct swm_info *swm_info, int write_flags) { size_t swm_name_len; tchar *swm_name_buf; const tchar *dot; tchar *swm_suffix; size_t swm_base_name_len; union wimlib_progress_info progress; unsigned part_number; int ret; u8 guid[GUID_SIZE]; swm_name_len = tstrlen(swm_name); swm_name_buf = alloca((swm_name_len + 20) * sizeof(tchar)); tstrcpy(swm_name_buf, swm_name); dot = tstrchr(swm_name_buf, T('.')); if (dot) { swm_base_name_len = dot - swm_name_buf; swm_suffix = alloca((tstrlen(dot) + 1) * sizeof(tchar)); tstrcpy(swm_suffix, dot); } else { swm_base_name_len = swm_name_len; swm_suffix = alloca(1 * sizeof(tchar)); swm_suffix[0] = T('\0'); } progress.split.completed_bytes = 0; progress.split.total_bytes = 0; for (part_number = 1; part_number <= swm_info->num_parts; part_number++) progress.split.total_bytes += swm_info->parts[part_number - 1].size; progress.split.total_parts = swm_info->num_parts; generate_guid(guid); for (part_number = 1; part_number <= swm_info->num_parts; part_number++) { int part_write_flags; wimlib_progress_func_t progfunc; if (part_number != 1) { tsprintf(swm_name_buf + swm_base_name_len, T("%u%"TS), part_number, swm_suffix); } progress.split.cur_part_number = part_number; progress.split.part_name = swm_name_buf; ret = call_progress(orig_wim->progfunc, WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART, &progress, orig_wim->progctx); if (ret) return ret; part_write_flags = write_flags; part_write_flags |= WIMLIB_WRITE_FLAG_USE_EXISTING_TOTALBYTES; if (part_number != 1) part_write_flags |= WIMLIB_WRITE_FLAG_NO_METADATA; progfunc = orig_wim->progfunc; orig_wim->progfunc = NULL; ret = write_wim_part(orig_wim, progress.split.part_name, WIMLIB_ALL_IMAGES, part_write_flags, 1, part_number, swm_info->num_parts, &swm_info->parts[part_number - 1].blob_list, guid); orig_wim->progfunc = progfunc; if (ret) return ret; progress.split.completed_bytes += swm_info->parts[part_number - 1].size; ret = call_progress(orig_wim->progfunc, WIMLIB_PROGRESS_MSG_SPLIT_END_PART, &progress, orig_wim->progctx); if (ret) return ret; } return 0; }
TEST(guid_test, easy) { char buf[GUID_BUF_LEN]; generate_guid(buf, sizeof(buf)); ASSERT_EQ(GUID_BUF_LEN - 1, strlen(buf)); }
TEST(guid_test, too_short) { char buf[5]; ASSERT_THROW(generate_guid(buf, sizeof(buf)), error_event); }
int main(int argc, char* argv[]) { char* config_path = NULL; char* pid_path = NULL; int daemon = 1; int c = 0; int pid_path_set = 0; int daemon_set = 0; pid_t pid = 0; eemo_rv rv = ERV_OK; while ((c = getopt(argc, argv, "fc:p:Ghv")) != -1) { switch(c) { case 'f': daemon = 0; daemon_set = 1; break; case 'c': config_path = strdup(optarg); if (config_path == NULL) { fprintf(stderr, "Error allocating memory, exiting\n"); return ERV_MEMORY; } break; case 'p': pid_path = strdup(optarg); if (pid_path == NULL) { fprintf(stderr, "Error allocating memory, exiting\n"); return ERV_MEMORY; } pid_path_set = 1; break; case 'G': generate_guid(); return 0; break; case 'h': usage(); return 0; case 'v': version(); return 0; } } if (config_path == NULL) { config_path = strdup(DEFAULT_EEMO_SENSOR_CONF); if (config_path == NULL) { fprintf(stderr, "Error allocating memory, exiting\n"); return ERV_MEMORY; } } if (pid_path == NULL) { pid_path = strdup(DEFAULT_EEMO_SENSOR_PIDFILE); if (pid_path == NULL) { fprintf(stderr, "Error allocating memory, exiting\n"); return ERV_MEMORY; } } /* Load the configuration */ if (eemo_init_config_handling(config_path) != ERV_OK) { fprintf(stderr, "Failed to load the configuration, exiting\n"); return ERV_CONFIG_ERROR; } /* Initialise logging */ if (eemo_init_log() != ERV_OK) { fprintf(stderr, "Failed to initialise logging, exiting\n"); return ERV_LOG_INIT_FAIL; } /* Determine configuration settings that were not specified on the command line */ if (!pid_path_set) { char* conf_pid_path = NULL; if (eemo_conf_get_string("daemon", "pidfile", &conf_pid_path, NULL) != ERV_OK) { ERROR_MSG("Failed to retrieve pidfile information from the configuration"); } else { if (conf_pid_path != NULL) { free(pid_path); pid_path = conf_pid_path; } } } if (!daemon_set) { if (eemo_conf_get_bool("daemon", "fork", &daemon, 1) != ERV_OK) { ERROR_MSG("Failed to retrieve daemon information from the configuration"); } } /* Now fork if that was requested */ if (daemon) { pid = fork(); if (pid != 0) { /* This is the parent process; write the PID file and exit */ write_pid(pid_path, pid); /* Unload the configuration */ if (eemo_uninit_config_handling() != ERV_OK) { ERROR_MSG("Failed to uninitialise configuration handling"); } /* Uninitialise logging */ if (eemo_uninit_log() != ERV_OK) { fprintf(stderr, "Failed to uninitialise logging\n"); } free(pid_path); free(config_path); return ERV_OK; } } /* If we forked, this is the child */ INFO_MSG("Starting the Extensible Ethernet Monitor Sensor (eemo_sensor) version %s", VERSION); INFO_MSG("eemo_sensor %sprocess ID is %d", daemon ? "daemon " : "", getpid()); /* Install signal handlers */ signal(SIGABRT, signal_handler); signal(SIGBUS, signal_handler); signal(SIGFPE, signal_handler); signal(SIGILL, signal_handler); signal(SIGPIPE, signal_handler); signal(SIGQUIT, signal_handler); signal(SIGSEGV, signal_handler); signal(SIGSYS, signal_handler); signal(SIGXCPU, signal_handler); signal(SIGXFSZ, signal_handler); /* Initialise OpenSSL */ SSL_library_init(); SSL_load_error_strings(); DEBUG_MSG("Initialised OpenSSL"); if (eemo_mt_openssl_init() != ERV_OK) { ERROR_MSG("Failed to initialise multi-thread use of OpenSSL"); return ERV_GENERAL_ERROR; } /* Initialise the sensor */ if (eemo_sensor_init() == ERV_OK) { /* Run the multiplexer until it is stopped */ eemo_sensor_run(); /* Uninitialise the sensor */ eemo_sensor_finalize(); } else { ERROR_MSG("Failed to initialise the sensor"); rv = ERV_GENERAL_ERROR; } /* Remove signal handlers */ signal(SIGABRT, SIG_DFL); signal(SIGBUS, SIG_DFL); signal(SIGFPE, SIG_DFL); signal(SIGILL, SIG_DFL); signal(SIGPIPE, SIG_DFL); signal(SIGQUIT, SIG_DFL); signal(SIGSEGV, SIG_DFL); signal(SIGSYS, SIG_DFL); signal(SIGXCPU, SIG_DFL); signal(SIGXFSZ, SIG_DFL); INFO_MSG("Extensible Ethernet Monitor Sensor exiting"); eemo_mt_openssl_finalize(); /* Uninitialise logging */ if (eemo_uninit_log() != ERV_OK) { fprintf(stderr, "Failed to uninitialise logging\n"); } free(pid_path); free(config_path); return rv; }