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;
}
