SO_PUBLIC struct RazorbackContext *
Razorback_Init_Inspection_Context (uuid_t p_uuidNuggetId,
uuid_t p_uuidApplicationType,
uint32_t p_iDataTypeCount,
uuid_t * p_pDataTypeList,
struct RazorbackInspectionHooks *p_pInspectionHooks,
uint32_t initialThreads, uint32_t maxThreads) {
struct RazorbackContext * context = calloc(1, sizeof(struct RazorbackContext));
uuid_parse("0", context->uuidApplicationType);
uuid_parse("0", context->uuidNuggetId);
uuid_parse("0", context->uuidNuggetType);
context->iFlags = 0;
context->iDataTypeCount = p_iDataTypeCount;
context->pDataTypeList = p_pDataTypeList;
context->pCommandHooks = NULL;
context->pInspectionHooks = p_pInspectionHooks;
function = p_pInspectionHooks->processBlock;
threadInit = p_pInspectionHooks->initThread;
threadCleanup = p_pInspectionHooks->cleanupThread;
if (!unshiftContext(context)) {
free(context);
rzb_log(LOG_ERR, "%s - failed to store context", __func__);
return NULL;
}
rzb_log(LOG_INFO, "Have inspection function pointer");
return context;
}
void* listenerThreadFunc(void* data) {
char filepath[1000], uuidStr[36], filetype[40], line[1100];
struct FileDefinition * f;
uuid_t uuid;
char c;
while (true) {
memset(filepath, '\0', 1000);
memset(uuidStr, '\0', 36);
memset(filetype, '\0', 40);
memset(line, '\0', 1100);
if (fgets(line, 1100, stdin) != NULL) {
sscanf(line, "--uuid=%s --type=%s --file=%s\n", uuidStr, filetype, filepath);
//printf("GOT: line=%s PARSED TO: --uuid=%s --type=%s --file=%s\n", line, uuidStr, filetype, filepath);
}
if ( strlen(filepath) > 0 ) {
if (strcmp(uuidStr, "none") != 0)
uuid_parse(uuidStr, uuid);
else if (strcmp(filetype, "none") != 0)
UUID_Get_UUID(filetype, UUID_TYPE_DATA_TYPE, uuid);
else
uuid_parse("0", uuid);
f = createFileDefinition(filepath, uuid);
Mutex_Lock(mutex);
pushFileList(f);
Mutex_Unlock(mutex);
} else {
usleep(500000);
}
}
return NULL;
}
TEST(uuid_test, test_all_uuid_funcs)
{
char u1str[36+1];
char u2str[36+1];
uuid_t u1;
uuid_t u2;
uuid_generate(u1);
uuid_generate_random(u2);
uuid_unparse(u1, u1str);
u1str[36] = 0;
uuid_unparse(u2, u2str);
u2str[36] = 0;
fprintf(stderr, "sizeof(uuid): %ld\n", sizeof(u1));
char zuid[36+1];
uuid_t tu;
tu = {0};
uuid_unparse(tu, zuid);
fprintf(stderr, "uuid(0): %s\n",zuid) ;
fprintf(stderr, "uuid_generate(): %s\n", u1str);
fprintf(stderr, "uuid_generate_random(): %s\n", u2str);
uuid_t u3;
uuid_parse(u1str, u3);
uuid_t u4;
uuid_parse(u2str, u4);
// should succeed
assert(uuid_compare(u1, u3) == 0);
// should fail
assert(uuid_compare(u1, u4) == 0);
}
DC_Workunit *_DC_getWUByName(const char *name)
{
DC_Workunit *wu;
char *uuid_str;
uuid_t uuid;
int ret;
if (_DC_wu_table)
{
wu = (DC_Workunit *)g_hash_table_lookup(_DC_wu_table, name);
if (wu)
return wu;
}
/* Check if the WU belongs to this application */
uuid_str = g_strndup(name, 36);
ret = uuid_parse(uuid_str, uuid);
g_free(uuid_str);
if (ret)
{
DC_log(LOG_ERR, "WU name contains illegal UUID");
return NULL;
}
if (uuid_compare(uuid, project_uuid))
{
DC_log(LOG_WARNING, "WU does not belong to this application");
return NULL;
}
if (name[36] != '_')
{
DC_log(LOG_ERR, "Illegal WU name syntax");
return NULL;
}
/* Check the WU's UUID */
uuid_str = g_strndup(name + 37, 36);
ret = uuid_parse(uuid_str, uuid);
g_free(uuid_str);
if (ret)
{
DC_log(LOG_ERR, "WU name contains illegal UUID");
return NULL;
}
DC_log(LOG_ERR, "WU %s not found!", name);
return NULL;
}
int
is_uuid(const char *value)
{
uuid_t id;
char test_value[37];
if (strlen(value) < 36) {
return 0;
}
if (uuid_is_null(id) < 0) {
errno = EINVAL;
return -1;
}
if (uuid_parse(value, id) < 0) {
return 0;
}
memset(test_value, 0, sizeof(test_value));
uuid_unparse(id, test_value);
if (strcasecmp(value, test_value)) {
return 0;
}
return 1;
}
static void
stratcon_datastore_journal(struct sockaddr *remote,
const char *remote_cn, char *line) {
interim_journal_t *ij = NULL;
char uuid_str[UUID_STR_LEN+1], *cp1, *cp2;
char rtype[256];
const char *fqdn = NULL, *dsn = NULL;
int storagenode_id = 0;
uuid_t checkid;
if(!line) {
mtevL(noit_error, "Error: Line not found for %s in stratcon_datastore_journal\n", remote_cn);
return;
}
cp1 = strchr(line, '\t');
*rtype = '\0';
if(cp1 && cp1 - line < sizeof(rtype) - 1) {
memcpy(rtype, line, cp1 - line);
rtype[cp1 - line] = '\0';
}
/* if it is a UUID based thing, find the storage node */
switch(*rtype) {
case 'C':
case 'S':
case 'M':
case 'D':
case 'B':
case 'H':
if((cp1 = strchr(cp1+1, '\t')) != NULL &&
(cp2 = strchr(cp1+1, '\t')) != NULL &&
(cp2-cp1 >= UUID_STR_LEN)) {
strlcpy(uuid_str, cp2 - UUID_STR_LEN, sizeof(uuid_str));
if(!uuid_parse(uuid_str, checkid)) {
ingestor->storage_node_lookup(uuid_str, remote_cn, NULL,
&storagenode_id, NULL,
&fqdn, &dsn);
ij = interim_journal_get(remote, remote_cn, storagenode_id, fqdn);
}
}
break;
case 'n':
ij = interim_journal_get(remote,remote_cn,0,NULL);
break;
default:
mtevL(noit_error, "Error: Line has bad type for %s in stratcon_datastore_journal (%s)\n", remote_cn, line);
break;
}
if(!ij) {
mtevL(ingest_err, "%d\t%s\n", storagenode_id, line);
}
else {
int len;
len = write(ij->fd, line, strlen(line));
if(len < 0) {
mtevL(noit_error, "write to %s failed: %s\n",
ij->filename, strerror(errno));
}
}
free(line);
return;
}
explicit unique_id_t(const identifier_type& other) {
if(uuid_parse(other.c_str(), m_uuid) == 0) {
m_id = other;
} else {
throw std::runtime_error("invalid unique id");
}
}
static krb5_error_code KRB5_CALLCONV
xcc_resolve(krb5_context context, krb5_ccache *id, const char *res)
{
krb5_error_code ret;
CFUUIDBytes bytes;
krb5_xcc *x;
if (uuid_parse(res, (void *)&bytes) != 0) {
krb5_set_error_message(context, KRB5_CC_END, "failed to parse uuid: %s", res);
return KRB5_CC_END;
}
CFUUIDRef uuidref = CFUUIDCreateFromUUIDBytes(NULL, bytes);
if (uuidref == NULL) {
krb5_set_error_message(context, KRB5_CC_END, "failed to create uuid from: %s", res);
return KRB5_CC_END;
}
ret = xcc_alloc(context, id);
if (ret) {
CFRELEASE_NULL(uuidref);
return ret;
}
x = XCACHE((*id));
x->uuid = uuidref;
genName(x);
return 0;
}
void get_uuid(char *in, uuid_t out) {
char t[37];
memcpy(t, in, 36);
t[36] = '\0';
PRs(t);
uuid_parse(t, out);
}
//Convert a string to unique id
uuid_t* stringToUniqueID(char* data)
{
int i;
uuid_t* uuid = malloc(sizeof(uuid_t));
uuid_parse(data, uuid);
return uuid;
}
void test_app_metadata_to_elem_works_without_event_id()
{
xmlNodePtr new_elem = NULL;
enum jal_status ret;
free(app_meta->event_id);
app_meta->event_id = NULL;
ret = jalp_app_metadata_to_elem(app_meta, ctx, doc, &new_elem);
assert_equals(JAL_OK, ret);
assert_not_equals(NULL, new_elem);
assert_tag_equals(APP_META_TAG, new_elem);
xmlDocSetRootElement(doc, new_elem);
assert_true(0 == validate(doc, __FUNCTION__, TEST_XML_APP_META_TYPES_SCHEMA, 0));
xmlChar *jid = xmlGetProp(new_elem, xml_jid_attr_name);
assert_true(0 == strncmp(JID_PREFIX, (char *)jid, strlen(JID_PREFIX)));
char *uuidstr = (char *)jid + strlen(JID_PREFIX);
uuid_t uuid;
assert_true(0 == uuid_parse(uuidstr, uuid));
xmlFree(jid);
xmlNodePtr custom = jal_get_first_element_child(new_elem);
assert_not_equals(NULL, custom);
assert_tag_equals(CUSTOM_TAG, custom);
xmlNodePtr should_be_null = custom->next;
assert_pointer_equals((void*)NULL, should_be_null);
}
/*ARGSUSED*/
int
cmd_deletekey(TSS_HCONTEXT hContext, TSS_HTPM hTPM, int argc, char *argv[])
{
TSS_RESULT ret;
TSS_HOBJECT hKey;
union {
uuid_t arr_uuid;
TSS_UUID tss_uuid;
} uuid;
if (argc < 2) {
(void) fprintf(stderr, gettext("Usage:\n"));
(void) fprintf(stderr, "\tdeletekey [uuid]\n");
return (ERR_USAGE);
}
if (uuid_parse(argv[1], uuid.arr_uuid))
return (ERR_FAIL);
ret = Tspi_Context_UnregisterKey(hContext, TSS_PS_TYPE_USER,
uuid.tss_uuid, &hKey);
if (ret == TSP_ERROR(TSS_E_PS_KEY_NOTFOUND)) {
ret = Tspi_Context_UnregisterKey(hContext, TSS_PS_TYPE_SYSTEM,
uuid.tss_uuid, &hKey);
}
if (ret) {
print_error(ret, gettext("Unregister key"));
return (ERR_FAIL);
}
return (0);
}
int
stratcon_realtime_uri_parse(realtime_context *rc, char *uri) {
int len, cnt = 0;
char *cp, *copy, *interest, *brk;
if(strncmp(uri, "/data/", 6)) return 0;
cp = uri + 6;
len = strlen(cp);
copy = alloca(len + 1);
if(!copy) return 0;
memcpy(copy, cp, len);
copy[len] = '\0';
for (interest = strtok_r(copy, "/", &brk);
interest;
interest = strtok_r(NULL, "/", &brk)) {
uuid_t in_uuid;
struct realtime_tracker *node;
char *interval;
interval = strchr(interest, '@');
if(!interval)
interval = "5000";
else
*interval++ = '\0';
if(uuid_parse(interest, in_uuid)) continue;
node = calloc(1, sizeof(*node));
node->rc = rc;
uuid_copy(node->checkid, in_uuid);
node->interval = atoi(interval);
node->next = rc->checklist;
rc->checklist = node;
cnt++;
}
return cnt;
}
static int Lisvalid(lua_State *L) /** isvalid(s) */
{
uuid_t c;
const char *s=luaL_checkstring(L,1);
lua_pushboolean(L,uuid_parse(s,c)==0);
return 1;
}
Status genUid(id_t& uid, uuid_string_t& uuid_str) {
CFDataRef uuid = nullptr;
if (!genUnlockIdent(uuid).ok()) {
if (uuid != nullptr) {
CFRelease(uuid);
}
return Status(1, "Could not get unlock ident");
}
CFDataGetBytes(uuid, CFRangeMake(0, CFDataGetLength(uuid)), (UInt8*)uuid_str);
if (uuid != nullptr) {
CFRelease(uuid);
}
uuid_t uuidT = {0};
if (uuid_parse(uuid_str, uuidT) != 0) {
return Status(1, "Could not parse UUID");
}
// id_type >=0 are all valid id types
int id_type = -1;
if (mbr_uuid_to_id(uuidT, &uid, &id_type) != 0 && id_type != ID_TYPE_UID) {
return Status(1, "Could not get uid from uuid");
}
return Status(0, "ok");
}
mtev_reverse_acl_decision_t
reverse_check_allow(const char *id, acceptor_closure_t *ac) {
mtev_hash_table *config;
noit_check_t *check;
const char *key;
uuid_t uuid;
char uuid_str[UUID_STR_LEN+1];
char expected_id[256];
if(strncmp(id, "check/", 6)) return MTEV_ACL_ABSTAIN;
strlcpy(uuid_str, id + 6, sizeof(uuid_str));
if(uuid_parse(uuid_str, uuid) != 0) return MTEV_ACL_DENY;
uuid_unparse_lower(uuid, uuid_str);
check = noit_poller_lookup(uuid);
if(!check) return MTEV_ACL_DENY;
config = noit_check_get_module_config(check, reverse_check_module_id);
if(config && mtev_hash_retr_str(config, "secret_key", strlen("secret_key"), &key)) {
snprintf(expected_id, sizeof(expected_id), "check/%s#%s", uuid_str, key);
}
else {
snprintf(expected_id, sizeof(expected_id), "check/%s", uuid_str);
}
if(!strncmp(id, expected_id, strlen(id))) return MTEV_ACL_ALLOW;
return MTEV_ACL_DENY;
}
void test_app_metadata_to_elem_works_for_logger()
{
xmlNodePtr new_elem = NULL;
enum jal_status ret;
app_meta->type = JALP_METADATA_LOGGER;
app_meta->log = logger_meta;
ret = jalp_app_metadata_to_elem(app_meta, ctx, doc, &new_elem);
assert_equals(JAL_OK, ret);
assert_not_equals(NULL, new_elem);
assert_tag_equals(APP_META_TAG, new_elem);
xmlDocSetRootElement(doc, new_elem);
assert_equals(0, validate(doc, __FUNCTION__, TEST_XML_APP_META_TYPES_SCHEMA, 0));
xmlChar *jid = xmlGetProp(new_elem, xml_jid_attr_name);
assert_equals(0, strncmp(JID_PREFIX, (char *)jid, strlen(JID_PREFIX)));
char *uuidstr = (char *)jid + strlen(JID_PREFIX);
uuid_t uuid;
assert_true(0 == uuid_parse(uuidstr, uuid));
xmlFree(jid);
xmlNodePtr event_id = jal_get_first_element_child(new_elem);
assert_not_equals(NULL, event_id);
assert_tag_equals(EVENT_ID_TAG, event_id);
assert_content_equals(EVENT_ID, event_id);
xmlNodePtr logger = event_id->next;
assert_not_equals(NULL, logger);
assert_tag_equals(LOGGER_TAG, logger);
xmlNodePtr should_be_null = logger->next;
assert_pointer_equals((void*)NULL, should_be_null);
app_meta->sys = NULL;
}
CID CID::FromString(const std::string &cid) {
uuid_t uuid;
int ret = uuid_parse(cid.data(), uuid);
if (ret == -1)
uuid_clear(uuid);
return CID(uuid);
}
static int Ltime(lua_State *L) /** time(s) */
{
uuid_t c;
const char *s=luaL_checkstring(L,1);
if (uuid_parse(s,c)!=0) return 0;
lua_pushnumber(L,uuid_time(c,NULL));
return 1;
}
static int Lparse(lua_State *L) /** parse(uuidstring) */
{
uuid_t c;
const char *s=luaL_checkstring(L,1);
if (uuid_parse(s,c))
return 0;
lua_pushlstring(L,(const char*)c,sizeof(c));
return 1;
}
void setup()
{
memset(&rec, 0, sizeof(rec));
memset(&app_meta, 0, sizeof(app_meta));
memset(&payload, 0, sizeof(payload));
rec.pid = 1234;
rec.uid = 5678;
rec.source = SOURCE;
rec.hostname = HOSTNAME;
rec.timestamp = TIMESTAMP;
rec.username = USERNAME;
rec.sec_lbl = SEC_LABEL;
rec.have_uid = 1;
rec.version = 1;
rec.payload = jaldb_create_segment();
assert_equals(0, uuid_parse(REC_UUID, rec.uuid));
assert_equals(0, uuid_parse(HOST_UUID, rec.host_uuid));
}
gboolean
nk_uuid_parse(NkUuid *self, const gchar *string)
{
if ( uuid_parse(string, self->data) < 0 )
return FALSE;
nk_uuid_update_string(self);
return TRUE;
}
BOOL UUID_FromString(PSTR szUUID,GUID *uuid)
{
#ifdef WIN32
return RPC_S_OK == UuidFromString(szUUID,uuid);
#endif //WIN32
#ifdef HAVE_UUID_PARSE
return uuid_parse(szUUID,uuid);
#endif //HAVE_UUID_PARSE
}
gboolean cbox_uuid_fromstring(struct cbox_uuid *uuid, const char *str, GError **error)
{
if (uuid_parse(str, uuid->uuid))
{
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Malformed UUID: '%s'", str);
return FALSE;
}
return TRUE;
}
gboolean
is_uuid_valid (const char *uuid_str)
{
uuid_t uuid;
if (uuid_parse (uuid_str, uuid) < 0)
return FALSE;
return TRUE;
}
int DC_initMaster(const char *config_file)
{
char *cfgval;
int ret;
_DC_init_common();
if (!config_file)
config_file = DC_CONFIG_FILE;
ret = _DC_parseCfg(config_file);
if (ret)
{
DC_log(LOG_ERR, "The DC-API cannot be initialized without a "
"config file");
return ret;
}
/* Check the working directory */
cfgval = DC_getCfgStr(CFG_WORKDIR);
if (!cfgval)
{
DC_log(LOG_ERR, "%s is not specified in the config file",
CFG_WORKDIR);
return DC_ERR_CONFIG;
}
free(cfgval);
/* Check sleep interval */
sleep_interval = DC_getCfgInt(CFG_SLEEPINTERVAL, DEFAULT_SLEEP_INTERVAL);
if (sleep_interval < 1)
sleep_interval = 1;
/* Check the project UUID */
cfgval = DC_getCfgStr(CFG_INSTANCEUUID);
if (!cfgval)
{
DC_log(LOG_ERR, "%s is not set in the config file",
CFG_INSTANCEUUID);
return DC_ERR_CONFIG;
}
ret = uuid_parse((char *)cfgval, project_uuid);
if (ret)
{
DC_log(LOG_ERR, "Invalid project UUID");
free(cfgval);
return DC_ERR_CONFIG;
}
free(cfgval);
/* Enforce a canonical string representation of the UUID */
uuid_unparse_lower(project_uuid, project_uuid_str);
return DC_OK;
}
/* Change the swap partition info */
static int change_info(const char *devname, const char *label, const char *uuid)
{
int fd;
fd = open(devname, O_RDWR);
if (fd < 0) {
warn(_("%s: failed to open"), devname);
goto err;
}
#ifdef HAVE_LIBUUID
/* Write the uuid if it was provided */
if (uuid) {
uuid_t newuuid;
if (uuid_parse(uuid, newuuid) == -1)
warnx(_("failed to parse UUID: %s"), uuid);
else {
if (lseek(fd, SWAP_UUID_OFFSET, SEEK_SET) !=
SWAP_UUID_OFFSET) {
warn(_("%s: failed to seek to swap UUID"), devname);
goto err;
} else if (write_all(fd, newuuid, sizeof(newuuid))) {
warn(_("%s: failed to write UUID"), devname);
goto err;
}
}
}
#endif
/* Write the label if it was provided */
if (label) {
char newlabel[SWAP_LABEL_LENGTH];
if (lseek(fd, SWAP_LABEL_OFFSET, SEEK_SET) != SWAP_LABEL_OFFSET) {
warn(_("%s: failed to seek to swap label "), devname);
goto err;
}
memset(newlabel, 0, sizeof(newlabel));
xstrncpy(newlabel, label, sizeof(newlabel));
if (strlen(label) > strlen(newlabel))
warnx(_("label is too long. Truncating it to '%s'"),
newlabel);
if (write_all(fd, newlabel, sizeof(newlabel))) {
warn(_("%s: failed to write label"), devname);
goto err;
}
}
close(fd);
return 0;
err:
if (fd >= 0)
close(fd);
return -1;
}
bool plUUID::FromString( const char * str )
{
Clear();
if ( !str )
return false;
uuid_t g;
uuid_parse( str, g );
plUUIDHelper::CopyToPlasma( this, g );
return true;
}
adapter::Guid
adapter::Guid::Parse(char const* s)
{
if (s == NULL)
return Guid::Null();
uuid_t id;
return (uuid_parse(s, id) == 0)
? Guid(id)
: Guid::Null();
}
bool UUID::initializeFromCString(const char* cstring)
{
# ifndef YUNI_OS_WINDOWS
// Why uuid_parse takes a char* and not a const char* ??
return !uuid_parse(const_cast<char*>(cstring), pValue.cstring);
# else
// Stop complaining, the Windows implementation is way worse.
char* cstring_noconst = const_cast<char*>(cstring);
unsigned char* cstring_unsigned = (unsigned char*)(cstring_noconst);
return RPC_S_OK == ::UuidFromStringA(cstring_unsigned, (::GUID*)pValue.cstring);
# endif
}
