mirror of
https://github.com/servalproject/serval-dna.git
synced 2025-02-01 00:45:28 +00:00
new function app_meshms_read_messagelog : read and display a messagelog file in hexa and ascii without parsing
This commit is contained in:
alexandrasclapari
parent
d05a3e2c45
commit
c215b006a3
204
commandline.c
204
commandline.c
@ -1470,6 +1470,149 @@ cleanup:
|
||||
return status;
|
||||
}
|
||||
|
||||
int app_meshms_read_messagelog(const struct cli_parsed *parsed, void *context)
|
||||
{
|
||||
if (config.debug.verbose)
|
||||
DEBUG_cli_parsed(parsed);
|
||||
|
||||
const char *manifestid , *bskhex ;
|
||||
|
||||
//const char *manifestpath, *filepath, *manifestid, *bskhex;
|
||||
|
||||
if (cli_arg(parsed, "manifestid", &manifestid, cli_manifestid, "") == -1 )
|
||||
return -1;
|
||||
//else {
|
||||
// cli_puts(manifestid);
|
||||
// cli_delim("\n");
|
||||
// }
|
||||
|
||||
//int extract = strcasecmp(parsed->args[1], "extract")==0;
|
||||
|
||||
// Ensure the Rhizome database exists and is open
|
||||
if (create_serval_instance_dir() == -1)
|
||||
return -1;
|
||||
if (rhizome_opendb() == -1)
|
||||
return -1;
|
||||
|
||||
// What does that mean ?
|
||||
if (!(keyring = keyring_open_instance_cli(parsed)))
|
||||
return -1;
|
||||
|
||||
int ret=0;
|
||||
|
||||
//manifestid is in hex
|
||||
unsigned char manifest_id[RHIZOME_MANIFEST_ID_BYTES];
|
||||
if (fromhexstr(manifest_id, manifestid, RHIZOME_MANIFEST_ID_BYTES) == -1)
|
||||
return WHY("Invalid manifest ID");
|
||||
|
||||
char manifestIdUpper[RHIZOME_MANIFEST_ID_STRLEN + 1];
|
||||
tohex(manifestIdUpper, manifest_id, RHIZOME_MANIFEST_ID_BYTES);
|
||||
|
||||
//cli_puts("manifestid"); cli_delim(":"); cli_puts(manifestIdUpper); cli_delim("\n");
|
||||
|
||||
// treat empty string the same as null
|
||||
if (bskhex && !*bskhex)
|
||||
bskhex=NULL;
|
||||
|
||||
rhizome_bk_t bsk;
|
||||
if (bskhex && fromhexstr(bsk.binary, bskhex, RHIZOME_BUNDLE_KEY_BYTES) == -1)
|
||||
return WHYF("invalid bsk: \"%s\"", bskhex);
|
||||
|
||||
rhizome_manifest *m = rhizome_new_manifest();
|
||||
if (m==NULL)
|
||||
return WHY("Out of manifests");
|
||||
|
||||
ret = rhizome_retrieve_manifest(manifestIdUpper, m);
|
||||
|
||||
if (ret==0){
|
||||
// ignore errors
|
||||
rhizome_extract_privatekey(m, NULL);
|
||||
const char *blob_service = rhizome_manifest_get(m, "service", NULL, 0);
|
||||
|
||||
cli_puts("service"); cli_delim(":"); cli_puts(blob_service); cli_delim("\n");
|
||||
cli_puts("manifestid"); cli_delim(":"); cli_puts(manifestIdUpper); cli_delim("\n");
|
||||
cli_puts("version"); cli_delim(":"); cli_printf("%lld", m->version); cli_delim("\n");
|
||||
cli_puts("inserttime"); cli_delim(":"); cli_printf("%lld", m->inserttime); cli_delim("\n");
|
||||
if (m->haveSecret) {
|
||||
cli_puts(".author"); cli_delim(":"); cli_puts(alloca_tohex_sid(m->author)); cli_delim("\n");
|
||||
}
|
||||
cli_puts(".readonly"); cli_delim(":"); cli_printf("%d", m->haveSecret?0:1); cli_delim("\n");
|
||||
cli_puts("filesize"); cli_delim(":"); cli_printf("%lld", (long long) m->fileLength); cli_delim("\n");
|
||||
if (m->fileLength != 0) {
|
||||
cli_puts("filehash"); cli_delim(":"); cli_puts(m->fileHexHash); cli_delim("\n");
|
||||
}
|
||||
}
|
||||
|
||||
int retfile=0;
|
||||
// ret=0 if retrieve manifest is ok
|
||||
if (ret==0 && m->fileLength != 0 ){
|
||||
// Rhizome_extract_file
|
||||
struct rhizome_read read_state;
|
||||
bzero(&read_state, sizeof read_state);
|
||||
int ret = rhizome_open_decrypt_read(m, bskhex?&bsk:NULL, &read_state, 1);
|
||||
if (ret == 0)
|
||||
cli_puts("the file exist, we will read the file"); cli_delim("\n");
|
||||
|
||||
int read_byte_version ;
|
||||
unsigned char *buffer_version;
|
||||
int buffer_length_version=100;
|
||||
buffer_version=malloc(100);
|
||||
read_byte_version=rhizome_read(&read_state, buffer_version, buffer_length_version);
|
||||
int i=0;
|
||||
cli_puts("read_byte_version");cli_delim(":");cli_printf("%d", read_byte_version); cli_delim("\n");
|
||||
hex_dump(buffer_version, buffer_length_version);
|
||||
|
||||
|
||||
|
||||
//ret = write_file(&read_state, filepath);
|
||||
rhizome_read_close(&read_state);}
|
||||
//return ret;
|
||||
|
||||
/*if (ret==0 && m->fileLength != 0 && filepath && *filepath){
|
||||
if (extract){
|
||||
|
||||
// Save the file, implicitly decrypting if required.
|
||||
// TODO, this may cause us to search for an author a second time if the above call to rhizome_extract_privatekey failed
|
||||
retfile = rhizome_extract_file(m, filepath, bskhex?&bsk:NULL);
|
||||
}else{
|
||||
// Save the file without attempting to decrypt
|
||||
int64_t length;
|
||||
retfile = rhizome_dump_file(m->fileHexHash, filepath, &length);
|
||||
}
|
||||
}
|
||||
|
||||
if (ret==0 && manifestpath && *manifestpath){
|
||||
if (strcmp(manifestpath, "-") == 0) {
|
||||
// always extract a manifest to stdout, even if writing the file itself failed.
|
||||
cli_puts("manifest");
|
||||
cli_delim(":");
|
||||
cli_write(m->manifestdata, m->manifest_all_bytes);
|
||||
cli_delim("\n");
|
||||
} else {
|
||||
int append = (strcmp(manifestpath, filepath)==0)?1:0;
|
||||
// don't write out the manifest if we were asked to append it and writing the file failed.
|
||||
if ((!append) || retfile==0){
|
||||
/* If the manifest has been read in from database, the blob is there,
|
||||
and we can lie and say we are finalised and just want to write it
|
||||
out. TODO: really should have a dirty/clean flag, so that write
|
||||
works if clean but not finalised.
|
||||
m->finalised=1;
|
||||
if (rhizome_write_manifest_file(m, manifestpath, append) == -1)
|
||||
ret = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (retfile)
|
||||
ret = retfile == -1 ? -1 : 1;
|
||||
if (m)
|
||||
rhizome_manifest_free(m);
|
||||
return ret; */
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
|
||||
int app_rhizome_append_manifest(const struct cli_parsed *parsed, void *context)
|
||||
{
|
||||
if (config.debug.verbose)
|
||||
@ -2358,6 +2501,9 @@ struct cli_schema command_line_options[]={
|
||||
"Get specified configuration variable."},
|
||||
{app_vomp_console,{"console",NULL},0,
|
||||
"Test phone call life-cycle from the console"},
|
||||
{app_meshms_read_messagelog,{"meshms","read", "messagelog" KEYRING_PIN_OPTIONS,
|
||||
"[<manifestid>]",NULL},CLIFLAG_STANDALONE,
|
||||
"List messages between a sender and a recipient"},
|
||||
{app_rhizome_append_manifest, {"rhizome", "append", "manifest", "<filepath>", "<manifestpath>", NULL}, CLIFLAG_STANDALONE,
|
||||
"Append a manifest to the end of the file it belongs to."},
|
||||
{app_rhizome_hash_file,{"rhizome","hash","file","<filepath>",NULL},CLIFLAG_STANDALONE,
|
||||
@ -2439,3 +2585,61 @@ struct cli_schema command_line_options[]={
|
||||
#endif
|
||||
{NULL,{NULL}}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
void hex_dump(char *data, int size)
|
||||
{
|
||||
int i; // index in data...
|
||||
int j; // index in line...
|
||||
char temp[8];
|
||||
char buffer[128];
|
||||
char *ascii;
|
||||
|
||||
memset(buffer, 0, 128);
|
||||
|
||||
printf("---------> Dump <--------- (%d bytes from %p)\n", size, data);
|
||||
|
||||
// Printing the ruler...
|
||||
printf(" +0 +4 +8 +c 0 4 8 c \n");
|
||||
|
||||
// Hex portion of the line is 8 (the padding) + 3 * 16 = 52 chars long
|
||||
// We add another four bytes padding and place the ASCII version...
|
||||
ascii = buffer + 58;
|
||||
memset(buffer, ' ', 58 + 16);
|
||||
buffer[58 + 16] = '\n';
|
||||
buffer[58 + 17] = '\0';
|
||||
buffer[0] = '+';
|
||||
buffer[1] = '0';
|
||||
buffer[2] = '0';
|
||||
buffer[3] = '0';
|
||||
buffer[4] = '0';
|
||||
for (i = 0, j = 0; i < size; i++, j++)
|
||||
{
|
||||
if (j == 16)
|
||||
{
|
||||
printf("%s", buffer);
|
||||
memset(buffer, ' ', 58 + 16);
|
||||
|
||||
sprintf(temp, "+%04x", i);
|
||||
memcpy(buffer, temp, 5);
|
||||
|
||||
j = 0;
|
||||
}
|
||||
|
||||
sprintf(temp, "%02x", 0xff & data[i]);
|
||||
memcpy(buffer + 8 + (j * 3), temp, 2);
|
||||
if ((data[i] > 31) && (data[i] < 127))
|
||||
ascii[j] = data[i];
|
||||
else
|
||||
ascii[j] = '.';
|
||||
}
|
||||
|
||||
if (j != 0)
|
||||
printf("%s", buffer);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -325,6 +325,9 @@ int rhizome_is_bar_interesting(unsigned char *bar);
|
||||
int rhizome_list_manifests(const char *service, const char *name,
|
||||
const char *sender_sid, const char *recipient_sid,
|
||||
int limit, int offset, char count_rows);
|
||||
int rhizome_list_manifests_forMeshMS(const char *service, const char *name,
|
||||
const char *sender_sid, const char *recipient_sid,
|
||||
int limit, int offset, char count_rows);
|
||||
int rhizome_retrieve_manifest(const char *manifestid, rhizome_manifest *m);
|
||||
int rhizome_advertise_manifest(rhizome_manifest *m);
|
||||
int rhizome_delete_bundle(const char *manifestid);
|
||||
@ -399,7 +402,7 @@ struct rhizome_write{
|
||||
|
||||
SHA512_CTX sha512_context;
|
||||
int64_t blob_rowid;
|
||||
int blob_fd;
|
||||
int blob_fd;
|
||||
};
|
||||
|
||||
struct rhizome_read{
|
||||
|
||||
@ -1203,6 +1203,199 @@ cleanup:
|
||||
OUT();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*int rhizome_list_manifests_forMeshMS(const char *service, const char *name,
|
||||
const char *sender_sid, const char *recipient_sid,
|
||||
int limit, int offset, char count_rows)
|
||||
{
|
||||
IN();
|
||||
strbuf b = strbuf_alloca(1024);
|
||||
strbuf_sprintf(b, "SELECT id, manifest, version, inserttime, author, rowid FROM manifests WHERE 1=1");
|
||||
|
||||
if (service && *service)
|
||||
strbuf_sprintf(b, " AND service = ?1");
|
||||
if (name && *name)
|
||||
strbuf_sprintf(b, " AND name like ?2");
|
||||
if (sender_sid && *sender_sid)
|
||||
strbuf_sprintf(b, " AND sender = ?3");
|
||||
if (recipient_sid && *recipient_sid)
|
||||
strbuf_sprintf(b, " AND recipient = ?4");
|
||||
|
||||
strbuf_sprintf(b, " ORDER BY inserttime DESC");
|
||||
|
||||
if (offset)
|
||||
strbuf_sprintf(b, " OFFSET %u", offset);
|
||||
|
||||
if (strbuf_overrun(b))
|
||||
RETURN(WHYF("SQL command too long: ", strbuf_str(b)));
|
||||
|
||||
sqlite_retry_state retry = SQLITE_RETRY_STATE_DEFAULT;
|
||||
sqlite3_stmt *statement = sqlite_prepare(&retry, "%s", strbuf_str(b));
|
||||
if (!statement)
|
||||
RETURN(-1);
|
||||
|
||||
int ret = 0;
|
||||
|
||||
if (service && *service)
|
||||
ret = sqlite3_bind_text(statement, 1, service, -1, SQLITE_STATIC);
|
||||
if (ret==SQLITE_OK && name && *name)
|
||||
ret = sqlite3_bind_text(statement, 2, name, -1, SQLITE_STATIC);
|
||||
if (ret==SQLITE_OK && sender_sid && *sender_sid)
|
||||
ret = sqlite3_bind_text(statement, 3, sender_sid, -1, SQLITE_STATIC);
|
||||
if (ret==SQLITE_OK && recipient_sid && *recipient_sid)
|
||||
ret = sqlite3_bind_text(statement, 4, recipient_sid, -1, SQLITE_STATIC);
|
||||
|
||||
if (ret!=SQLITE_OK){
|
||||
ret = WHYF("Failed to bind parameters: %s", sqlite3_errmsg(rhizome_db));
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
ret=0;
|
||||
size_t rows = 0;
|
||||
|
||||
const char *names[]={
|
||||
"_id",
|
||||
"service",
|
||||
"id",
|
||||
"version",
|
||||
"date",
|
||||
".inserttime",
|
||||
".author",
|
||||
".fromhere",
|
||||
"filesize",
|
||||
"filehash",
|
||||
"sender",
|
||||
"recipient",
|
||||
"name"
|
||||
};
|
||||
cli_columns(13,names);
|
||||
|
||||
while (sqlite_step_retry(&retry, statement) == SQLITE_ROW) {
|
||||
++rows;
|
||||
if (limit>0 && rows>limit)
|
||||
break;
|
||||
if (!( sqlite3_column_count(statement) == 6
|
||||
&& sqlite3_column_type(statement, 0) == SQLITE_TEXT
|
||||
&& sqlite3_column_type(statement, 1) == SQLITE_BLOB
|
||||
&& sqlite3_column_type(statement, 2) == SQLITE_INTEGER
|
||||
&& sqlite3_column_type(statement, 3) == SQLITE_INTEGER
|
||||
&& ( sqlite3_column_type(statement, 4) == SQLITE_TEXT
|
||||
|| sqlite3_column_type(statement, 4) == SQLITE_NULL
|
||||
)
|
||||
)) {
|
||||
ret = WHY("Incorrect statement column");
|
||||
break;
|
||||
}
|
||||
rhizome_manifest *m = rhizome_new_manifest();
|
||||
if (m == NULL) {
|
||||
ret = WHY("Out of manifests");
|
||||
break;
|
||||
}
|
||||
const char *q_manifestid = (const char *) sqlite3_column_text(statement, 0);
|
||||
const char *manifestblob = (char *) sqlite3_column_blob(statement, 1);
|
||||
size_t manifestblobsize = sqlite3_column_bytes(statement, 1); // must call after sqlite3_column_blob()
|
||||
long long q_version = sqlite3_column_int64(statement, 2);
|
||||
long long q_inserttime = sqlite3_column_int64(statement, 3);
|
||||
const char *q_author = (const char *) sqlite3_column_text(statement, 4);
|
||||
long long rowid = sqlite3_column_int64(statement, 5);
|
||||
|
||||
if (rhizome_read_manifest_file(m, manifestblob, manifestblobsize) == -1) {
|
||||
WARNF("MANIFESTS row id=%s has invalid manifest blob -- skipped", q_manifestid);
|
||||
} else {
|
||||
long long blob_version = rhizome_manifest_get_ll(m, "version");
|
||||
if (blob_version != q_version)
|
||||
WARNF("MANIFESTS row id=%s version=%lld does not match manifest blob.version=%lld", q_manifestid, q_version, blob_version);
|
||||
int match = 1;
|
||||
|
||||
const char *blob_service = rhizome_manifest_get(m, "service", NULL, 0);
|
||||
if (service[0] && !(blob_service && strcasecmp(service, blob_service) == 0))
|
||||
match = 0;
|
||||
const char *blob_sender = rhizome_manifest_get(m, "sender", NULL, 0);
|
||||
const char *blob_recipient = rhizome_manifest_get(m, "recipient", NULL, 0);
|
||||
if (match && sender_sid[0]) {
|
||||
if (!(blob_sender && strcasecmp(sender_sid, blob_sender) == 0))
|
||||
match = 0;
|
||||
}
|
||||
if (match && recipient_sid[0]) {
|
||||
if (!(blob_recipient && strcasecmp(recipient_sid, blob_recipient) == 0))
|
||||
match = 0;
|
||||
}
|
||||
|
||||
if (match) {
|
||||
const char *blob_name = rhizome_manifest_get(m, "name", NULL, 0);
|
||||
long long blob_date = rhizome_manifest_get_ll(m, "date");
|
||||
const char *blob_filehash = rhizome_manifest_get(m, "filehash", NULL, 0);
|
||||
int from_here = 0;
|
||||
unsigned char senderSid[SID_SIZE];
|
||||
unsigned char recipientSid[SID_SIZE];
|
||||
|
||||
if (blob_sender)
|
||||
stowSid(senderSid, 0, blob_sender);
|
||||
if (blob_recipient)
|
||||
stowSid(recipientSid, 0, blob_recipient);
|
||||
|
||||
if (q_author) {
|
||||
if (config.debug.rhizome) DEBUGF("q_author=%s", alloca_str_toprint(q_author));
|
||||
stowSid(m->author, 0, q_author);
|
||||
int cn = 0, in = 0, kp = 0;
|
||||
from_here = keyring_find_sid(keyring, &cn, &in, &kp, m->author);
|
||||
}
|
||||
if (!from_here && blob_sender) {
|
||||
if (config.debug.rhizome) DEBUGF("blob_sender=%s", alloca_str_toprint(blob_sender));
|
||||
int cn = 0, in = 0, kp = 0;
|
||||
from_here = keyring_find_sid(keyring, &cn, &in, &kp, senderSid);
|
||||
}
|
||||
|
||||
//cli_put_long(rowid, ":");
|
||||
//cli_put_string(blob_service, ":");
|
||||
cli_put_hexvalue(m->cryptoSignPublic, RHIZOME_MANIFEST_ID_BYTES, ":");
|
||||
//cli_put_long(blob_version, ":");
|
||||
//cli_put_long(blob_date, ":");
|
||||
//cli_put_long(q_inserttime, ":");
|
||||
//cli_put_hexvalue(q_author?m->author:NULL, SID_SIZE, ":");
|
||||
//cli_put_long(from_here, ":");
|
||||
//cli_put_long(m->fileLength, ":");
|
||||
|
||||
unsigned char filehash[SHA512_DIGEST_LENGTH];
|
||||
if (m->fileLength)
|
||||
fromhex(filehash, blob_filehash, SHA512_DIGEST_LENGTH);
|
||||
|
||||
//cli_put_hexvalue(m->fileLength?filehash:NULL, SHA512_DIGEST_LENGTH, ":");
|
||||
|
||||
//cli_put_hexvalue(blob_sender?senderSid:NULL, SID_SIZE, ":");
|
||||
//cli_put_hexvalue(blob_recipient?recipientSid:NULL, SID_SIZE, ":");
|
||||
cli_put_string(blob_name, "\n");
|
||||
}
|
||||
}
|
||||
if (m) rhizome_manifest_free(m);
|
||||
}
|
||||
|
||||
if (ret==0 && count_rows){
|
||||
while (sqlite_step_retry(&retry, statement) == SQLITE_ROW)
|
||||
++rows;
|
||||
}
|
||||
cli_row_count(rows);
|
||||
|
||||
cleanup:
|
||||
sqlite3_finalize(statement);
|
||||
RETURN(ret);
|
||||
OUT();
|
||||
} */
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void rhizome_bytes_to_hex_upper(unsigned const char *in, char *out, int byteCount)
|
||||
{
|
||||
(void) tohex(out, in, byteCount);
|
||||
@ -1380,7 +1573,7 @@ int rhizome_find_duplicate(const rhizome_manifest *m, rhizome_manifest **found,
|
||||
}
|
||||
|
||||
if ((!inconsistent) && check_author) {
|
||||
// check that we can re-author this manifest
|
||||
// check that we can re-author this manifest
|
||||
if (rhizome_extract_privatekey(blob_m, NULL))
|
||||
++inconsistent;
|
||||
}
|
||||
@ -1618,4 +1811,4 @@ int rhizome_is_bar_interesting(unsigned char *bar){
|
||||
|
||||
RETURN(ret);
|
||||
OUT();
|
||||
}
|
||||
}
|
||||
|
||||
@ -498,9 +498,13 @@ int rhizome_read(struct rhizome_read *read_state, unsigned char *buffer, int buf
|
||||
IN();
|
||||
int bytes_read = 0;
|
||||
if (read_state->blob_fd != -1) {
|
||||
if (lseek(read_state->blob_fd, read_state->offset, SEEK_SET) == -1)
|
||||
//positionne le pointeur
|
||||
if (lseek(read_state->blob_fd, read_state->offset, SEEK_SET) == -1)
|
||||
RETURN(WHYF_perror("lseek(%d,%ld,SEEK_SET)", read_state->blob_fd, (long)read_state->offset));
|
||||
|
||||
// read buffer-lenght char and store in buffer
|
||||
bytes_read = read(read_state->blob_fd, buffer, buffer_length);
|
||||
|
||||
if (bytes_read == -1)
|
||||
RETURN(WHYF_perror("read(%d,%p,%ld)", read_state->blob_fd, buffer, (long)buffer_length));
|
||||
} else if (read_state->blob_rowid != -1) {
|
||||
@ -546,7 +550,7 @@ int rhizome_read(struct rhizome_read *read_state, unsigned char *buffer, int buf
|
||||
char hash_out[SHA512_DIGEST_STRING_LENGTH+1];
|
||||
SHA512_End(&read_state->sha512_context, hash_out);
|
||||
if (strcasecmp(read_state->id, hash_out)){
|
||||
WHYF("Expected hash=%s, got %s", read_state->id, hash_out);
|
||||
WHYF("Expected hash=%s, got %s", read_state->id, hash_out);
|
||||
}
|
||||
read_state->hash=0;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user