int getUniqueName( char *name ) { int ret=0; #ifdef USE_UUID if(name==NULL){ return -1; } uuid_t *uuid = (unsigned char*)malloc (sizeof (uuid_t)); //char *uuid_str = (char*)malloc (37 * sizeof (char)); uuid_generate_random (uuid); uuid_unparse(uuid, name); //printf ("%s\n", uuid_str); //free (uuid_str); free (uuid); #endif return ret; }
static int it_iqn_generate(char *iqn_buf, int iqn_buf_len, char *opt_iqn_suffix) { int ret; uuid_t id; char id_str[UUID_PRINTABLE_STRING_LENGTH]; uuid_generate_random(id); uuid_unparse(id, id_str); if (opt_iqn_suffix) { ret = snprintf(iqn_buf, iqn_buf_len, DEFAULT_IQN "%02d:%s.%s", TARGET_NAME_VERS, id_str, opt_iqn_suffix); } else { ret = snprintf(iqn_buf, iqn_buf_len, DEFAULT_IQN "%02d:%s", TARGET_NAME_VERS, id_str); } if (ret > iqn_buf_len) { return (1); } return (0); }
/** * This function transmits the code to the user * @param pam_user The user login * @param pam_email The user email address * @param pam_code The generated code * @return A PAM return code */ int pam_transmit_code(pam_handle_t *pam_handle, const char *pam_user, const char *pam_email, const char *pam_code) { /* The curl instance */ CURL *curl; /* The curl return */ CURLcode res = CURLE_OK; /* The recipents list */ struct curl_slist *recipients = NULL; /* The email contect */ struct pam_email_ctx email_ctx; /* The email id */ uuid_t uuid; char email_id[37]; /* The mail server configuration */ const char *pam_mail_server_host; const char *pam_mail_server_user; const char *pam_mail_server_pass; /* The module configuration */ config_t pam_config; FILE *pam_config_fd; /* The module dialogs */ struct pam_message *pam_dialog_message[1]; struct pam_message pam_dialog_message_ptr[1]; struct pam_response *pam_dialog_response; /* Init PAM dialog variables */ pam_dialog_message[0] = &pam_dialog_message_ptr[0]; pam_dialog_response = NULL; /* Generate a random id for email */ uuid_generate_random(uuid); /* Init configuration */ config_init(&pam_config); /* Init configuration file stream */ if((pam_config_fd = fopen("/etc/aurora/email.conf", "r")) == NULL) { /* An error occurs */ pam_dialog_message_ptr[0].msg_style = PAM_ERROR_MSG; pam_dialog_message_ptr[0].msg = "[ERROR] Unable to open configuration"; pam_converse(pam_handle, 1, pam_dialog_message, &pam_dialog_response); /* Properly destroy the configuration */ config_destroy(&pam_config); /* Reject authentication */ return PAM_AUTH_ERR; } /* Read and parse the configuration file */ if(config_read(&pam_config, pam_config_fd) == CONFIG_FALSE) { /* An error occurs */ pam_dialog_message_ptr[0].msg_style = PAM_ERROR_MSG; pam_dialog_message_ptr[0].msg = "[ERROR] Unable to read configuration"; pam_converse(pam_handle, 1, pam_dialog_message, &pam_dialog_response); /* Properly destroy the configuration */ config_destroy(&pam_config); /* Properly destroy the configuration file stream */ fclose(pam_config_fd); /* Reject authentication */ return PAM_AUTH_ERR; } /* Get mail server settings */ if( (config_lookup_string(&pam_config, "mail_server_host", &pam_mail_server_host) == CONFIG_FALSE) || (config_lookup_string(&pam_config, "mail_server_user", &pam_mail_server_user) == CONFIG_FALSE) || (config_lookup_string(&pam_config, "mail_server_pass", &pam_mail_server_pass) == CONFIG_FALSE) ) { /* An error occurs */ pam_dialog_message_ptr[0].msg_style = PAM_ERROR_MSG; pam_dialog_message_ptr[0].msg = "[ERROR] Mail server configuration not found"; pam_converse(pam_handle, 1, pam_dialog_message, &pam_dialog_response); /* Properly destroy the directory */ config_destroy(&pam_config); /* Reject authentication */ return PAM_AUTH_ERR; } /* Set email context */ email_ctx.from = (char*) pam_mail_server_user; email_ctx.to = (char*) pam_email; email_ctx.user = (char*) pam_user; email_ctx.code = (char*) pam_code; uuid_unparse(uuid, email_id); email_ctx.uuid = email_id; email_ctx.current_line = 0; /* Init curl */ curl = curl_easy_init(); if(curl) { /* Set server url */ curl_easy_setopt(curl, CURLOPT_URL, (char*) pam_mail_server_host); /* Set username */ curl_easy_setopt(curl, CURLOPT_USERNAME, (char*) pam_mail_server_user); /* Set password */ curl_easy_setopt(curl, CURLOPT_PASSWORD, (char*) pam_mail_server_pass); /* Enable SSL */ curl_easy_setopt(curl, CURLOPT_USE_SSL, (long) CURLUSESSL_ALL); /* Set sender */ curl_easy_setopt(curl, CURLOPT_MAIL_FROM, (void *) email_ctx.from); /* Set secipients */ recipients = curl_slist_append(recipients, (void *) email_ctx.to); curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients); /* Register the payload function */ curl_easy_setopt(curl, CURLOPT_READFUNCTION, pam_payload_email_source); /* Set the email context */ curl_easy_setopt(curl, CURLOPT_READDATA, &email_ctx); /* Enable upload */ curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L); /* Send email */ res = curl_easy_perform(curl); if(res != CURLE_OK) { /* An error occurs */ pam_dialog_message_ptr[0].msg_style = PAM_ERROR_MSG; pam_dialog_message_ptr[0].msg = "[ERROR] Email transmission failure"; pam_converse(pam_handle, 1, pam_dialog_message, &pam_dialog_response); /* Free memory */ config_destroy(&pam_config); curl_slist_free_all(recipients); curl_easy_cleanup(curl); /* Reject authentication */ return PAM_AUTH_ERR; } /* Free memory */ config_destroy(&pam_config); curl_slist_free_all(recipients); curl_easy_cleanup(curl); } /* Transmission success */ return PAM_SUCCESS; }
/* function call from lmlite with parameters */ void network_devices_status_report(struct networkdevicestatusdata *head, BOOL extender, char* parent_mac) { int i = 0, k = 0; uint8_t* b64buffer = NULL; size_t decodesize = 0; int numElements = 0; struct networkdevicestatusdata* ptr = head; avro_writer_t writer; char * serviceName = "lmlite"; char * dest = "event:raw.kestrel.reports.NetworkDevicesStatus"; char * contentType = "avro/binary"; // contentType "application/json", "avro/binary" uuid_t transaction_id; char trans_id[37]; char CpeMacHoldingBuf[ 20 ] = {0}; unsigned char CpeMacid[ 7 ] = {0}; CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s : ENTER \n", __FUNCTION__ )); numElements = NumberofElementsinLinkedList(head); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, numElements = %d\n", numElements )); OneAvroSerializedSize = 0; /* goes thru total number of elements in link list */ writer = prepare_writer_status(); //Reset out writer avro_writer_reset(writer); //Network Device Report avro_value_t adr; avro_generic_value_new(iface, &adr); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, GatewayNetworkDeviceStatusReport\tType: %d\n", avro_value_get_type(&adr))); avro_value_t adrField = {0,0}; avro_value_t array = {0,0}; size_t new_index = 0; //Optional value for unions, mac address is an union avro_value_t optional = {0,0}; // timestamp - long avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "timestamp", &adrField, NULL); avro_value_set_branch(&adrField, 1, &optional); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); struct timeval ts; gettimeofday(&ts, NULL); #ifndef UTC_ENABLE int64_t tstamp_av_main = ((int64_t) (ts.tv_sec - getTimeOffsetFromUtc()) * 1000000) + (int64_t) ts.tv_usec; #else int64_t tstamp_av_main = ((int64_t) (ts.tv_sec) * 1000000) + (int64_t) ts.tv_usec; #endif tstamp_av_main = tstamp_av_main/1000; avro_value_set_long(&optional, tstamp_av_main ); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp = ""%" PRId64 "\n", tstamp_av_main )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // uuid - fixed 16 bytes uuid_generate_random(transaction_id); uuid_unparse(transaction_id, trans_id); avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "uuid", &adrField, NULL); avro_value_set_branch(&adrField, 1, &optional); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_fixed(&optional, transaction_id, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, uuid\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //source - string avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "source", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, ReportSource); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, source\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); if ( extender == FALSE ) { //cpe_id block /* MAC - Get CPE mac address, do it only pointer is NULL */ memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); if ( macStr == NULL ) { macStr = getDeviceMac(); strncpy( CpemacStr, macStr, sizeof(CpemacStr)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",macStr)); } for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = CpemacStr[ k * 2 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = CpemacStr[ k * 2 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address = %0x\n", CpeMacid[ k ] )); } avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "mac_address", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, mac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_type - string avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_type", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, CPE_TYPE_GATEWAY_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_parent - Recurrsive CPEIdentifier block avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_parent", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 0, &optional); avro_value_set_null(&optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_parent\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); } else { //cpe_id block avro_value_t parent_optional = {0,0}, parent_adrField = {0,0}; memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = parent_mac[ k * 3 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = parent_mac[ k * 3 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Extender Mac address = %0x\n", CpeMacid[ k ] )); } avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "mac_address", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, mac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_type - string avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_type", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, CPE_TYPE_EXTENDER_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_parent - Recurrsive CPEIdentifier block avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_parent", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); /* MAC - Get CPE mac address, do it only pointer is NULL */ if ( macStr == NULL ) { macStr = getDeviceMac(); strncpy( CpemacStr, macStr, sizeof(CpemacStr)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",macStr)); } memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = CpemacStr[ k * 2 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = CpemacStr[ k * 2 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG Parent Mac address = %0x\n", CpeMacid[ k ] )); } // assume 1 parent ONLY // Parent MAC avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "mac_address", &parent_adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&parent_adrField, 1, &parent_optional); avro_value_set_fixed(&parent_optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent mac_address\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // Parent cpe_type avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "cpe_type", &parent_adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&parent_adrField, 1, &parent_optional); avro_value_set_string(&parent_optional, CPE_TYPE_GATEWAY_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent cpe_type\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // no more parent, set NULL avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "cpe_parent", &parent_adrField, NULL); avro_value_set_branch(&parent_adrField, 0, &parent_optional); avro_value_set_null(&parent_optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent cpe_parent\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); } //host_table_version block avro_value_get_by_name(&adr, "host_table_version", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_long(&optional, lmHosts.lastActivity); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, host_table_version\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //Data Field block avro_value_get_by_name(&adr, "data", &adrField, NULL); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, NetworkDeviceStatusReports - data array\tType: %d\n", avro_value_get_type(&adrField))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //adrField now contains a reference to the AssociatedDeviceReportsArray //Device Report avro_value_t dr = {0,0}; //Current Device Report Field avro_value_t drField = {0,0}; while(ptr) { if( (!strcmp(ptr->parent, parent_mac) && (extender == TRUE)) || (extender == FALSE) ) { CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Current Link List Ptr = [0x%lx], numElements = %d\n", (ulong)ptr, numElements )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tDevice entry #: %d\n", i + 1)); //Append a DeviceReport item to array avro_value_append(&adrField, &dr, NULL); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tDevice Status Report\tType: %d\n", avro_value_get_type(&dr))); //data array block memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address from node list = %s \n", ptr->device_mac )); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = ptr->device_mac[ k * 3 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = ptr->device_mac[ k * 3 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address = %0x\n", CpeMacid[ k ] )); } //device_mac - fixed 6 bytes avro_value_get_by_name(&dr, "device_id", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, device_id\tType: %d\n", avro_value_get_type(&drField))); avro_value_get_by_name(&drField, "mac_address", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tmac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //device_type - string avro_value_get_by_name(&dr, "device_id", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, device_id\tType: %d\n", avro_value_get_type(&drField))); avro_value_get_by_name(&drField, "device_type", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_string(&optional, ptr->device_type); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tdevice_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //timestamp - long avro_value_get_by_name(&dr, "timestamp", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); int64_t tstamp_av = (int64_t) ptr->timestamp.tv_sec * 1000000 + (int64_t) ptr->timestamp.tv_usec; tstamp_av = tstamp_av/1000; avro_value_set_long(&optional, tstamp_av); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp = ""%" PRId64 "\n", tstamp_av )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \ttimestamp\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //interface_name - string avro_value_get_by_name(&dr, "interface_name", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); //avro_value_set_string(&optional, " aa "); avro_value_set_string(&optional, ptr->interface_name ); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tinterface_name\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //status - enum avro_value_get_by_name(&dr, "status", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, status\tType: %d\n", avro_value_get_type(&optional))); if ( ptr->is_active ) avro_value_set_enum(&optional, avro_schema_enum_get_by_name(avro_value_get_schema(&optional), "ONLINE")); else avro_value_set_enum(&optional, avro_schema_enum_get_by_name(avro_value_get_schema(&optional), "OFFLINE")); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //hostname - string avro_value_get_by_name(&dr, "hostname", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_string(&optional, ptr->hostname); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \thostname\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //ipaddress - array avro_value_get_by_name(&dr, "ip_addresses", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_append(&optional, &array, NULL); avro_value_set_string(&array, ptr->ipaddress); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tipaddress\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); i++; } #if SIMULATION ptr = 0; #else ptr = ptr->next; // next link list #endif /* check for writer size, if buffer is almost full, skip trailing linklist */ avro_value_sizeof(&adr, &AvroSerializedSize); OneAvroSerializedSize = ( OneAvroSerializedSize == 0 ) ? AvroSerializedSize : OneAvroSerializedSize; if ( ( WRITER_BUF_SIZE - AvroSerializedSize ) < OneAvroSerializedSize ) { CcspLMLiteTrace(("RDK_LOG_ERROR, AVRO write buffer is almost full, size = %d func %s, exit!\n", (int)AvroSerializedSize, __FUNCTION__ )); break; } } //Thats the end of that avro_value_write(writer, &adr); avro_value_sizeof(&adr, &AvroSerializedSize); AvroSerializedSize += MAGIC_NUMBER_SIZE + SCHEMA_ID_LENGTH; CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Serialized writer size %d\n", (int)AvroSerializedSize)); //Free up memory avro_value_decref(&adr); avro_writer_free(writer); //free(buffer); /* if ( consoleDebugEnable ) { // b64 encoding decodesize = b64_get_encoded_buffer_size( AvroSerializedSize ); b64buffer = malloc(decodesize * sizeof(uint8_t)); b64_encode( (uint8_t*)AvroSerializedBuf, AvroSerializedSize, b64buffer); fprintf( stderr, "\nAVro serialized data\n"); for (k = 0; k < (int)AvroSerializedSize ; k++) { char buf[30]; if ( ( k % 32 ) == 0 ) fprintf( stderr, "\n"); sprintf(buf, "%02X", (unsigned char)AvroSerializedBuf[k]); fprintf( stderr, "%c%c", buf[0], buf[1] ); } fprintf( stderr, "\n\nB64 data\n"); for (k = 0; k < (int)decodesize; k++) { if ( ( k % 32 ) == 0 ) fprintf( stderr, "\n"); fprintf( stderr, "%c", b64buffer[k]); } fprintf( stderr, "\n\n"); free(b64buffer); }*/ CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Before ND WebPA SEND message call\n")); #ifdef PARODUS_ENABLE CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, serviceName: %s\n", serviceName)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, dest: %s\n", dest)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, trans_id: %s\n", trans_id)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, contentType: %s\n", contentType)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, AvroSerializedBuf: %s\n", AvroSerializedBuf)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, AvroSerializedSize: %d\n", (int)AvroSerializedSize)); #endif // Send data from LMLite to webpa using CCSP bus interface sendWebpaMsg(serviceName, dest, trans_id, contentType, AvroSerializedBuf, AvroSerializedSize); CcspTraceWarning(("NetworkDevicesStatus report sent to Webpa, Destination=%s, Transaction-Id=%s \n",dest,trans_id)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, After ND WebPA SEND message call\n")); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s : EXIT \n", __FUNCTION__ )); #if SIMULATION exit(0); #endif }
DECLARE_TEST( uuid, generate ) { int iloop; uuid_t uuid, uuid_ref; char name_str[] = "com.rampantpixels.foundation.uuid.000000"; uuid = uuid_null(); uuid_ref = uuid_null(); EXPECT_TRUE( uuid_is_null( uuid ) ); EXPECT_TRUE( uuid_is_null( uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) ); //Random based uuid = uuid_generate_random(); uuid_ref = uuid_null(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_TRUE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_generate_random(); uuid_ref = uuid_generate_random(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_ref; EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); for( iloop = 0; iloop < 64000; ++iloop ) { uuid_ref = uuid; uuid = uuid_generate_random(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); } //Time based uuid = uuid_generate_time(); uuid_ref = uuid_null(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_TRUE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_generate_time(); uuid_ref = uuid_generate_time(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_ref; EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); for( iloop = 0; iloop < 64000; ++iloop ) { uuid_ref = uuid; uuid = uuid_generate_time(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); } //Name based uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid" ); uuid_ref = uuid_null(); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_TRUE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.1" ); uuid_ref = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.2" ); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); uuid = uuid_generate_name( UUID_DNS, "com.rampantpixels.foundation.uuid.2" ); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid, uuid_ref ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); for( iloop = 0; iloop < 10000; ++iloop ) { string_format_buffer( name_str, 40, "com.rampantpixels.foundation.uuid.%05u", iloop ); uuid_ref = uuid; uuid = uuid_generate_name( UUID_DNS, name_str ); EXPECT_FALSE( uuid_is_null( uuid ) ); EXPECT_FALSE( uuid_is_null( uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid, uuid_ref ) ); EXPECT_FALSE( uuid_equal( uuid_ref, uuid ) ); EXPECT_TRUE( uuid_equal( uuid, uuid ) ); EXPECT_TRUE( uuid_equal( uuid_ref, uuid_ref ) ); } return 0; }
/* * This is the generic front-end */ void uuid_generate(uuid_t out) { uuid_generate_random(out); }
/* * Creates a new UUID. The uuid will be generated based on high-quality * randomness from arc4random(3C). */ void uuid_generate(uuid_t uu) { uuid_generate_random(uu); }
static Datum uuid_generate_internal(int v, unsigned char *ns, char *ptr, int len) { char strbuf[40]; switch (v) { case 0: /* constant-value uuids */ strlcpy(strbuf, ptr, 37); break; case 1: /* time/node-based uuids */ { #ifdef HAVE_UUID_E2FS uuid_t uu; uuid_generate_time(uu); uuid_unparse(uu, strbuf); /* * PTR, if set, replaces the trailing characters of the uuid; * this is to support v1mc, where a random multicast MAC is * used instead of the physical one */ if (ptr && len <= 36) strcpy(strbuf + (36 - len), ptr); #else /* BSD */ uuid_t uu; uint32_t status = uuid_s_ok; char *str = NULL; uuid_create(&uu, &status); if (status == uuid_s_ok) { uuid_to_string(&uu, &str, &status); if (status == uuid_s_ok) { strlcpy(strbuf, str, 37); /* * PTR, if set, replaces the trailing characters of * the uuid; this is to support v1mc, where a random * multicast MAC is used instead of the physical one */ if (ptr && len <= 36) strcpy(strbuf + (36 - len), ptr); } if (str) free(str); } if (status != uuid_s_ok) ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("uuid library failure: %d", (int) status))); #endif break; } case 3: /* namespace-based MD5 uuids */ case 5: /* namespace-based SHA1 uuids */ { dce_uuid_t uu; #ifdef HAVE_UUID_BSD uint32_t status = uuid_s_ok; char *str = NULL; #endif if (v == 3) { MD5_CTX ctx; MD5Init(&ctx); MD5Update(&ctx, ns, sizeof(uu)); MD5Update(&ctx, (unsigned char *) ptr, len); /* we assume sizeof MD5 result is 16, same as UUID size */ MD5Final((unsigned char *) &uu, &ctx); } else { SHA1_CTX ctx; unsigned char sha1result[SHA1_RESULTLEN]; SHA1Init(&ctx); SHA1Update(&ctx, ns, sizeof(uu)); SHA1Update(&ctx, (unsigned char *) ptr, len); SHA1Final(sha1result, &ctx); memcpy(&uu, sha1result, sizeof(uu)); } /* the calculated hash is using local order */ UUID_TO_NETWORK(uu); UUID_V3_OR_V5(uu, v); #ifdef HAVE_UUID_E2FS /* uuid_unparse expects local order */ UUID_TO_LOCAL(uu); uuid_unparse((unsigned char *) &uu, strbuf); #else /* BSD */ uuid_to_string(&uu, &str, &status); if (status == uuid_s_ok) strlcpy(strbuf, str, 37); if (str) free(str); if (status != uuid_s_ok) ereport(ERROR, (errcode(ERRCODE_EXTERNAL_ROUTINE_EXCEPTION), errmsg("uuid library failure: %d", (int) status))); #endif break; } case 4: /* random uuid */ default: { #ifdef HAVE_UUID_E2FS uuid_t uu; uuid_generate_random(uu); uuid_unparse(uu, strbuf); #else /* BSD */ snprintf(strbuf, sizeof(strbuf), "%08lx-%04x-%04x-%04x-%04x%08lx", (unsigned long) arc4random(), (unsigned) (arc4random() & 0xffff), (unsigned) ((arc4random() & 0xfff) | 0x4000), (unsigned) ((arc4random() & 0x3fff) | 0x8000), (unsigned) (arc4random() & 0xffff), (unsigned long) arc4random()); #endif break; } } return DirectFunctionCall1(uuid_in, CStringGetDatum(strbuf)); }
static int load_server_status(PSERVER_DATA server) { uuid_t uuid; char uuid_str[37]; int ret; char url[4096]; int i; i = 0; do { char *pairedText = NULL; char *currentGameText = NULL; char *versionText = NULL; char *stateText = NULL; char *heightText = NULL; char *serverCodecModeSupportText = NULL; ret = GS_INVALID; uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); // Modern GFE versions don't allow serverinfo to be fetched over HTTPS if the client // is not already paired. Since we can't pair without knowing the server version, we // make another request over HTTP if the HTTPS request fails. We can't just use HTTP // for everything because it doesn't accurately tell us if we're paired. sprintf(url, "%s://%s:%d/serverinfo?uniqueid=%s&uuid=%s", i == 0 ? "https" : "http", server->address, i == 0 ? 47984 : 47989, unique_id, uuid_str); PHTTP_DATA data = http_create_data(); if (data == NULL) { ret = GS_OUT_OF_MEMORY; goto cleanup; } if (http_request(url, data) != GS_OK) { ret = GS_IO_ERROR; goto cleanup; } if (xml_search(data->memory, data->size, "currentgame", ¤tGameText) != GS_OK) { goto cleanup; } if (xml_search(data->memory, data->size, "PairStatus", &pairedText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "appversion", &versionText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "state", &stateText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "Height", &heightText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "ServerCodecModeSupport", &serverCodecModeSupportText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "gputype", &server->gpuType) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "GfeVersion", &server->gfeVersion) != GS_OK) goto cleanup; // These fields are present on all version of GFE that this client supports if (!strlen(currentGameText) || !strlen(pairedText) || !strlen(versionText) || !strlen(stateText)) goto cleanup; server->paired = pairedText != NULL && strcmp(pairedText, "1") == 0; server->currentGame = currentGameText == NULL ? 0 : atoi(currentGameText); server->supports4K = heightText != NULL && serverCodecModeSupportText != NULL && atoi(heightText) >= 2160; server->serverMajorVersion = atoi(versionText); if (strstr(stateText, "_SERVER_AVAILABLE")) { // After GFE 2.8, current game remains set even after streaming // has ended. We emulate the old behavior by forcing it to zero // if streaming is not active. server->currentGame = 0; } ret = GS_OK; cleanup: if (data != NULL) http_free_data(data); if (pairedText != NULL) free(pairedText); if (currentGameText != NULL) free(currentGameText); if (versionText != NULL) free(versionText); if (heightText != NULL) free(heightText); if (serverCodecModeSupportText != NULL) free(serverCodecModeSupportText); i++; } while (ret != GS_OK && i < 2); if (ret == GS_OK) { if (server->serverMajorVersion > MAX_SUPPORTED_GFE_VERSION) { gs_error = "Ensure you're running the latest version of Moonlight Embedded or downgrade GeForce Experience and try again"; ret = GS_UNSUPPORTED_VERSION; } else if (server->serverMajorVersion < MIN_SUPPORTED_GFE_VERSION) { gs_error = "Moonlight Embedded requires a newer version of GeForce Experience. Please upgrade GFE on your PC and try again."; ret = GS_UNSUPPORTED_VERSION; } } return ret; }
/* * Create an interface for the guest using Apple's vmnet framework. * * The interface works in VMNET_SHARED_MODE which allows for packets * of the guest to reach other guests and the Internet. * * See also: https://developer.apple.com/library/mac/documentation/vmnet/Reference/vmnet_Reference/index.html */ static int vmn_create(struct pci_vtnet_softc *sc) { xpc_object_t interface_desc; uuid_t uuid; __block interface_ref iface; __block vmnet_return_t iface_status; dispatch_semaphore_t iface_created; dispatch_queue_t if_create_q; dispatch_queue_t if_q; struct vmnet_state *vms; uint32_t uuid_status; interface_desc = xpc_dictionary_create(NULL, NULL, 0); xpc_dictionary_set_uint64(interface_desc, vmnet_operation_mode_key, VMNET_SHARED_MODE); if (guest_uuid_str != NULL) { uuid_from_string(guest_uuid_str, &uuid, &uuid_status); if (uuid_status != uuid_s_ok) { return (-1); } } else { uuid_generate_random(uuid); } xpc_dictionary_set_uuid(interface_desc, vmnet_interface_id_key, uuid); iface = NULL; iface_status = 0; vms = malloc(sizeof(struct vmnet_state)); if (!vms) { return (-1); } if_create_q = dispatch_queue_create("org.xhyve.vmnet.create", DISPATCH_QUEUE_SERIAL); iface_created = dispatch_semaphore_create(0); iface = vmnet_start_interface(interface_desc, if_create_q, ^(vmnet_return_t status, xpc_object_t interface_param) { iface_status = status; if (status != VMNET_SUCCESS || !interface_param) { dispatch_semaphore_signal(iface_created); return; } if (sscanf(xpc_dictionary_get_string(interface_param, vmnet_mac_address_key), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &vms->mac[0], &vms->mac[1], &vms->mac[2], &vms->mac[3], &vms->mac[4], &vms->mac[5]) != 6) { assert(0); } vms->mtu = (unsigned) xpc_dictionary_get_uint64(interface_param, vmnet_mtu_key); vms->max_packet_size = (unsigned) xpc_dictionary_get_uint64(interface_param, vmnet_max_packet_size_key); dispatch_semaphore_signal(iface_created); });
/* Determines the GUID * Returns 1 if successful or -1 on error */ int guid_generate( uint8_t *guid, size_t guid_size, uint8_t guid_type, liberror_error_t **error ) { #if defined( WINAPI ) UUID uuid = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } }; #endif static char *function = "guid_generate"; if( guid == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid GUID.", function ); return( -1 ); } if( guid_size < GUID_SIZE ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: GUID too small.", function ); return( -1 ); } if( guid_size > (size_t) SSIZE_MAX ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid GUID size value exceeds maximum.", function ); return( -1 ); } if( ( guid_type != GUID_TYPE_RANDOM ) && ( guid_type != GUID_TYPE_TIME ) ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported GUID type.", function ); return( -1 ); } if( guid_type == GUID_TYPE_RANDOM ) { #if defined( WINAPI ) UuidCreate( &uuid ); #elif defined( HAVE_UUID_GENERATE_RANDOM ) uuid_generate_random( guid ); #endif } if( guid_type == GUID_TYPE_TIME ) { #if defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520 /* No support for the time type GUID */ #elif defined( WINAPI ) && _WIN32_WINNT >= 0x0500 UuidCreateSequential( &uuid ); #elif defined( HAVE_UUID_GENERATE_TIME ) uuid_generate_time( guid ); #endif } #if defined( WINAPI ) byte_stream_copy_from_uint32_little_endian( guid, uuid.Data1 ); guid += 4; byte_stream_copy_from_uint16_little_endian( guid, uuid.Data2 ); guid += 2; byte_stream_copy_from_uint16_little_endian( guid, uuid.Data3 ); guid += 2; guid[ 0 ] = uuid.Data4[ 0 ]; guid[ 1 ] = uuid.Data4[ 1 ]; guid[ 2 ] = uuid.Data4[ 2 ]; guid[ 3 ] = uuid.Data4[ 3 ]; guid[ 4 ] = uuid.Data4[ 4 ]; guid[ 5 ] = uuid.Data4[ 5 ]; guid[ 6 ] = uuid.Data4[ 6 ]; guid[ 7 ] = uuid.Data4[ 7 ]; #endif return( 1 ); }
int gs_pair(PSERVER_DATA server, char* pin) { int ret = GS_OK; char url[4096]; uuid_t uuid; char uuid_str[37]; if (server->paired) { gs_error = "Already paired"; return GS_WRONG_STATE; } if (server->currentGame != 0) { gs_error = "The computer is currently in a game. You must close the game before pairing"; return GS_WRONG_STATE; } unsigned char salt_data[16]; char salt_hex[33]; RAND_bytes(salt_data, 16); bytes_to_hex(salt_data, salt_hex, 16); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&phrase=getservercert&salt=%s&clientcert=%s", server->address, unique_id, uuid_str, salt_hex, cert_hex); PHTTP_DATA data = http_create_data(); if (data == NULL) return GS_OUT_OF_MEMORY; else if ((ret = http_request(url, data)) != GS_OK) goto cleanup; unsigned char salt_pin[20]; unsigned char aes_key_hash[20]; AES_KEY aes_key; memcpy(salt_pin, salt_data, 16); memcpy(salt_pin+16, salt_pin, 4); SHA1(salt_pin, 20, aes_key_hash); AES_set_encrypt_key((unsigned char *)aes_key_hash, 128, &aes_key); unsigned char challenge_data[16]; unsigned char challenge_enc[16]; char challenge_hex[33]; RAND_bytes(challenge_data, 16); AES_encrypt(challenge_data, challenge_enc, &aes_key); bytes_to_hex(challenge_enc, challenge_hex, 16); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&clientchallenge=%s", server->address, unique_id, uuid_str, challenge_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; char *result; if (xml_search(data->memory, data->size, "challengeresponse", &result) != GS_OK) { ret = GS_INVALID; goto cleanup; } char challenge_response_data_enc[48]; char challenge_response_data[48]; for (int count = 0; count < strlen(result); count++) { sscanf(&result[count], "%2hhx", &challenge_response_data_enc[count / 2]); } free(result); for (int i = 0; i < 48; i += 16) { AES_decrypt(&challenge_response_data_enc[i], &challenge_response_data[i], &aes_key); } char client_secret_data[16]; RAND_bytes(client_secret_data, 16); char challenge_response[16 + 256 + 16]; char challenge_response_hash[32]; char challenge_response_hash_enc[32]; char challenge_response_hex[33]; memcpy(challenge_response, challenge_response_data + 20, 16); memcpy(challenge_response + 16, cert->signature->data, 256); memcpy(challenge_response + 16 + 256, client_secret_data, 16); SHA1(challenge_response, 16 + 256 + 16, challenge_response_hash); for (int i = 0; i < 32; i += 16) { AES_encrypt(&challenge_response_hash[i], &challenge_response_hash_enc[i], &aes_key); } bytes_to_hex(challenge_response_hash_enc, challenge_response_hex, 32); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&serverchallengeresp=%s", server->address, unique_id, uuid_str, challenge_response_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "pairingsecret", &result) != GS_OK) { ret = GS_INVALID; goto cleanup; } unsigned char *signature = NULL; size_t s_len; if (sign_it(client_secret_data, 16, &signature, &s_len, privateKey) != GS_OK) { gs_error = "Failed to sign data"; ret = GS_FAILED; goto cleanup; } char client_pairing_secret[16 + 256]; char client_pairing_secret_hex[(16 + 256) * 2 + 1]; memcpy(client_pairing_secret, client_secret_data, 16); memcpy(client_pairing_secret + 16, signature, 256); bytes_to_hex(client_pairing_secret, client_pairing_secret_hex, 16 + 256); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&clientpairingsecret=%s", server->address, unique_id, uuid_str, client_pairing_secret_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "https://%s:47984/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&phrase=pairchallenge", server->address, unique_id, uuid_str); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; server->paired = true; cleanup: http_free_data(data); return ret; }
static int load_server_status(PSERVER_DATA server) { char *pairedText = NULL; char *currentGameText = NULL; char *versionText = NULL; char *stateText = NULL; uuid_t uuid; char uuid_str[37]; int ret = GS_INVALID; char url[4096]; uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "https://%s:47984/serverinfo?uniqueid=%s&uuid=%s", server->address, unique_id, uuid_str); PHTTP_DATA data = http_create_data(); if (data == NULL) { ret = GS_OUT_OF_MEMORY; goto cleanup; } if (http_request(url, data) != GS_OK) { ret = GS_IO_ERROR; goto cleanup; } if (xml_search(data->memory, data->size, "currentgame", ¤tGameText) != GS_OK) { goto cleanup; } if (xml_search(data->memory, data->size, "PairStatus", &pairedText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "appversion", &versionText) != GS_OK) goto cleanup; if (xml_search(data->memory, data->size, "state", &stateText) != GS_OK) goto cleanup; server->paired = pairedText != NULL && strcmp(pairedText, "1") == 0; server->currentGame = currentGameText == NULL ? 0 : atoi(currentGameText); char *versionSep = strstr(versionText, "."); if (versionSep != NULL) { *versionSep = 0; } server->serverMajorVersion = atoi(versionText); if (strstr(stateText, "_SERVER_AVAILABLE")) { // After GFE 2.8, current game remains set even after streaming // has ended. We emulate the old behavior by forcing it to zero // if streaming is not active. server->currentGame = 0; } ret = GS_OK; cleanup: if (data != NULL) http_free_data(data); if (pairedText != NULL) free(pairedText); if (currentGameText != NULL) free(currentGameText); if (versionText != NULL) free(versionText); return ret; }
int _environment_initialize( const application_t application ) { #if FOUNDATION_PLATFORM_WINDOWS int ia; int num_args = 0; DWORD ret = 0; wchar_t module_filename[FOUNDATION_MAX_PATHLEN]; LPWSTR* arg_list = CommandLineToArgvW( GetCommandLineW(), &num_args ); if( !arg_list ) return -1; for( ia = 0; ia < num_args; ++ia ) array_push( _environment_argv, string_allocate_from_wstring( arg_list[ia], 0 ) ); LocalFree( arg_list ); if( GetModuleFileNameW( 0, module_filename, FOUNDATION_MAX_PATHLEN ) ) { char* exe_path = string_allocate_from_wstring( module_filename, 0 ); char* dir_path = path_make_absolute( exe_path ); _environment_set_executable_paths( dir_path ); string_deallocate( dir_path ); string_deallocate( exe_path ); } else { log_errorf( ERROR_SYSTEM_CALL_FAIL, "Unable to get module filename" ); return -1; } #elif FOUNDATION_PLATFORM_APPLE int ia; int* argc_ptr = _NSGetArgc(); char*** argv_ptr = _NSGetArgv(); for( ia = 0; ia < *argc_ptr; ++ia ) array_push( _environment_argv, string_clone( (*argv_ptr)[ia] ) ); FOUNDATION_ASSERT( *argc_ptr > 0 ); char* exe_path = path_make_absolute( (*argv_ptr)[0] ); _environment_set_executable_paths( exe_path ); string_deallocate( exe_path ); #elif FOUNDATION_PLATFORM_POSIX stream_t* cmdline = fs_open_file( "/proc/self/cmdline", STREAM_IN | STREAM_BINARY ); if( !cmdline ) { log_errorf( ERROR_SYSTEM_CALL_FAIL, "Unable to read /proc/self/cmdline" ); return -1; } while( true ) { char* arg = stream_read_string( cmdline ); if( !string_length( arg ) ) { string_deallocate( arg ); break; } array_push( _environment_argv, arg ); } char exelink[FOUNDATION_MAX_PATHLEN] = {0}; if( readlink( "/proc/self/exe", exelink, FOUNDATION_MAX_PATHLEN ) < 0 ) { log_errorf( ERROR_SYSTEM_CALL_FAIL, "Unable to read /proc/self/exe link" ); return -1; } char* exe_path; char* dir_path; exe_path = path_clean( string_clone( exelink ), path_is_absolute( exelink ) ); dir_path = path_make_absolute( exe_path ); _environment_set_executable_paths( dir_path ); string_deallocate( dir_path ); string_deallocate( exe_path ); #else # error Not implemented /*if( array_size( _environment_argv ) > 0 ) { char* exe_path = path_clean( string_clone( _environment_argv[0] ), path_is_absolute( _environment_argv[0] ) ); char* dir_path = path_make_absolute( exe_path ); _environment_set_executable_paths( dir_path ); string_deallocate( dir_path ); string_deallocate( exe_path ); } else if( !string_length( _environment_executable_dir ) ) string_copy( _environment_executable_dir, environment_current_working_directory(), FOUNDATION_MAX_PATHLEN ); */ #endif _environment_app = application; if( uuid_is_null( _environment_app.instance ) ) _environment_app.instance = uuid_generate_random(); string_copy( _environment_initial_working_dir, environment_current_working_directory(), FOUNDATION_MAX_PATHLEN ); environment_temporary_directory(); return 0; }
/* * Creates a DFS root with the given name and comment. * * This function does not create the root share, it * should already exist. */ uint32_t dfs_namespace_add(const char *rootshr, const char *cmnt) { dfs_info_t info; dfs_target_t t; smb_share_t si; uuid_t uuid; uint32_t status; if (*rootshr == '\\') { /* Windows has a special case here! */ return (ERROR_BAD_PATHNAME); } if (smb_shr_get((char *)rootshr, &si) != NERR_Success) return (NERR_NetNameNotFound); (void) mutex_lock(&dfs_nsmtx); if (smb_strcasecmp(dfs_cached_ns, rootshr, 0) == 0) { /* This DFS root is already exported */ (void) mutex_unlock(&dfs_nsmtx); return (ERROR_FILE_EXISTS); } if (*dfs_cached_ns != '\0') { syslog(LOG_WARNING, "dfs: trying to add %s namespace." " Only one standalone namespace is supported." " A namespace is already exported for %s", rootshr, dfs_cached_ns); (void) mutex_unlock(&dfs_nsmtx); return (ERROR_NOT_SUPPORTED); } bzero(&info, sizeof (info)); if (cmnt) (void) strlcpy(info.i_comment, cmnt, sizeof (info.i_comment)); info.i_state = DFS_VOLUME_STATE_OK | DFS_VOLUME_FLAVOR_STANDALONE; info.i_timeout = DFS_ROOT_TIMEOUT; info.i_propflags = 0; uuid_generate_random(uuid); uuid_unparse(uuid, info.i_guid); dfs_target_init(&t, dfs_nbname, rootshr, DFS_STORAGE_STATE_ONLINE); info.i_ntargets = 1; info.i_targets = &t; if ((status = dfs_root_add(si.shr_path, &info)) != ERROR_SUCCESS) { (void) mutex_unlock(&dfs_nsmtx); return (status); } status = srvsvc_shr_setdfsroot(&si, B_TRUE); if (status == ERROR_SUCCESS) { (void) dfs_cache_add_byname(rootshr, NULL, DFS_OBJECT_ROOT); (void) strlcpy(dfs_cached_ns, rootshr, sizeof (dfs_cached_ns)); (void) smb_config_setnum(SMB_CI_DFS_STDROOT_NUM, 1); } (void) mutex_unlock(&dfs_nsmtx); return (status); }
int gs_pair(PSERVER_DATA server, char* pin) { int ret = GS_OK; char* result = NULL; char url[4096]; uuid_t uuid; char uuid_str[37]; if (server->paired) { gs_error = "Already paired"; return GS_WRONG_STATE; } if (server->currentGame != 0) { gs_error = "The computer is currently in a game. You must close the game before pairing"; return GS_WRONG_STATE; } unsigned char salt_data[16]; char salt_hex[33]; RAND_bytes(salt_data, 16); bytes_to_hex(salt_data, salt_hex, 16); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&phrase=getservercert&salt=%s&clientcert=%s", server->address, unique_id, uuid_str, salt_hex, cert_hex); PHTTP_DATA data = http_create_data(); if (data == NULL) return GS_OUT_OF_MEMORY; else if ((ret = http_request(url, data)) != GS_OK) goto cleanup; if ((ret = xml_search(data->memory, data->size, "paired", &result)) != GS_OK) goto cleanup; if (strcmp(result, "1") != 0) { gs_error = "Pairing failed"; ret = GS_FAILED; goto cleanup; } free(result); result = NULL; if ((ret = xml_search(data->memory, data->size, "plaincert", &result)) != GS_OK) goto cleanup; if (strlen(result)/2 > 8191) { gs_error = "Server certificate too big"; ret = GS_FAILED; goto cleanup; } char plaincert[8192]; for (int count = 0; count < strlen(result); count += 2) { sscanf(&result[count], "%2hhx", &plaincert[count / 2]); } plaincert[strlen(result)/2] = '\0'; printf("%d / %d\n", strlen(result)/2, strlen(plaincert)); unsigned char salt_pin[20]; unsigned char aes_key_hash[32]; AES_KEY enc_key, dec_key; memcpy(salt_pin, salt_data, 16); memcpy(salt_pin+16, pin, 4); int hash_length = server->serverMajorVersion >= 7 ? 32 : 20; if (server->serverMajorVersion >= 7) SHA256(salt_pin, 20, aes_key_hash); else SHA1(salt_pin, 20, aes_key_hash); AES_set_encrypt_key((unsigned char *)aes_key_hash, 128, &enc_key); AES_set_decrypt_key((unsigned char *)aes_key_hash, 128, &dec_key); unsigned char challenge_data[16]; unsigned char challenge_enc[16]; char challenge_hex[33]; RAND_bytes(challenge_data, 16); AES_encrypt(challenge_data, challenge_enc, &enc_key); bytes_to_hex(challenge_enc, challenge_hex, 16); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&clientchallenge=%s", server->address, unique_id, uuid_str, challenge_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; free(result); result = NULL; if ((ret = xml_search(data->memory, data->size, "paired", &result)) != GS_OK) goto cleanup; if (strcmp(result, "1") != 0) { gs_error = "Pairing failed"; ret = GS_FAILED; goto cleanup; } free(result); result = NULL; if (xml_search(data->memory, data->size, "challengeresponse", &result) != GS_OK) { ret = GS_INVALID; goto cleanup; } char challenge_response_data_enc[48]; char challenge_response_data[48]; for (int count = 0; count < strlen(result); count += 2) { sscanf(&result[count], "%2hhx", &challenge_response_data_enc[count / 2]); } for (int i = 0; i < 48; i += 16) { AES_decrypt(&challenge_response_data_enc[i], &challenge_response_data[i], &dec_key); } char client_secret_data[16]; RAND_bytes(client_secret_data, 16); char challenge_response[16 + 256 + 16]; char challenge_response_hash[32]; char challenge_response_hash_enc[32]; char challenge_response_hex[65]; memcpy(challenge_response, challenge_response_data + hash_length, 16); memcpy(challenge_response + 16, cert->signature->data, 256); memcpy(challenge_response + 16 + 256, client_secret_data, 16); if (server->serverMajorVersion >= 7) SHA256(challenge_response, 16 + 256 + 16, challenge_response_hash); else SHA1(challenge_response, 16 + 256 + 16, challenge_response_hash); for (int i = 0; i < 32; i += 16) { AES_encrypt(&challenge_response_hash[i], &challenge_response_hash_enc[i], &enc_key); } bytes_to_hex(challenge_response_hash_enc, challenge_response_hex, 32); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&serverchallengeresp=%s", server->address, unique_id, uuid_str, challenge_response_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; free(result); result = NULL; if ((ret = xml_search(data->memory, data->size, "paired", &result)) != GS_OK) goto cleanup; if (strcmp(result, "1") != 0) { gs_error = "Pairing failed"; ret = GS_FAILED; goto cleanup; } free(result); result = NULL; if (xml_search(data->memory, data->size, "pairingsecret", &result) != GS_OK) { ret = GS_INVALID; goto cleanup; } char pairing_secret[16 + 256]; for (int count = 0; count < strlen(result); count += 2) { sscanf(&result[count], "%2hhx", &pairing_secret[count / 2]); } if (!verifySignature(pairing_secret, 16, pairing_secret+16, 256, plaincert)) { gs_error = "MITM attack detected"; ret = GS_FAILED; goto cleanup; } unsigned char *signature = NULL; size_t s_len; if (sign_it(client_secret_data, 16, &signature, &s_len, privateKey) != GS_OK) { gs_error = "Failed to sign data"; ret = GS_FAILED; goto cleanup; } char client_pairing_secret[16 + 256]; char client_pairing_secret_hex[(16 + 256) * 2 + 1]; memcpy(client_pairing_secret, client_secret_data, 16); memcpy(client_pairing_secret + 16, signature, 256); bytes_to_hex(client_pairing_secret, client_pairing_secret_hex, 16 + 256); uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "http://%s:47989/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&clientpairingsecret=%s", server->address, unique_id, uuid_str, client_pairing_secret_hex); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; free(result); result = NULL; if ((ret = xml_search(data->memory, data->size, "paired", &result)) != GS_OK) goto cleanup; if (strcmp(result, "1") != 0) { gs_error = "Pairing failed"; ret = GS_FAILED; goto cleanup; } uuid_generate_random(uuid); uuid_unparse(uuid, uuid_str); sprintf(url, "https://%s:47984/pair?uniqueid=%s&uuid=%s&devicename=roth&updateState=1&phrase=pairchallenge", server->address, unique_id, uuid_str); if ((ret = http_request(url, data)) != GS_OK) goto cleanup; free(result); result = NULL; if ((ret = xml_search(data->memory, data->size, "paired", &result)) != GS_OK) goto cleanup; if (strcmp(result, "1") != 0) { gs_error = "Pairing failed"; ret = GS_FAILED; goto cleanup; } server->paired = true; cleanup: if (ret != GS_OK) gs_unpair(server); if (result != NULL) free(result); http_free_data(data); return ret; }
int render_import(stream_t* stream, const uuid_t uuid_given) { renderimport_type_t type = IMPORTTYPE_UNKNOWN; renderimport_type_t guess = IMPORTTYPE_UNKNOWN; uuid_t uuid = uuid_given; string_const_t path; string_const_t extension; int ret; bool store_import = false; path = stream_path(stream); extension = path_file_extension(STRING_ARGS(path)); if (string_equal_nocase(STRING_ARGS(extension), STRING_CONST("shader"))) guess = IMPORTTYPE_SHADER; else if (string_equal_nocase(STRING_ARGS(extension), STRING_CONST("program"))) guess = IMPORTTYPE_PROGRAM; type = render_import_shader_guess_type(stream); if ((type == IMPORTTYPE_UNKNOWN) && (guess != IMPORTTYPE_UNKNOWN)) type = guess; if (type == IMPORTTYPE_UNKNOWN) return -1; if (uuid_is_null(uuid)) uuid = resource_import_lookup(STRING_ARGS(path)).uuid; if (uuid_is_null(uuid)) { uuid = uuid_generate_random(); store_import = true; } if (store_import) { uuid_t founduuid = resource_import_map_store(STRING_ARGS(path), uuid, uint256_null()); if (uuid_is_null(founduuid)) { log_warn(HASH_RESOURCE, WARNING_SUSPICIOUS, STRING_CONST("Unable to open import map file to store new resource")); return -1; } uuid = founduuid; } switch (type) { case IMPORTTYPE_PROGRAM: ret = render_import_program(stream, uuid); break; case IMPORTTYPE_SHADER: ret = render_import_shader(stream, uuid); break; case IMPORTTYPE_GLSL_VERTEXSHADER: ret = render_import_glsl_vertexshader(stream, uuid); break; case IMPORTTYPE_GLSL_PIXELSHADER: ret = render_import_glsl_pixelshader(stream, uuid); break; case IMPORTTYPE_UNKNOWN: default: return -1; } if (ret == 0) resource_import_map_store(STRING_ARGS(path), uuid, stream_sha256(stream)); return ret; }
void nuuid_generate(struct nuuid *uuid) { uuid_generate_random(uuid->raw); }