passe du codage base64 à hexa pour les bytestrings

git-svn-id: https://redmine.imt-atlantique.fr/svn/xaal/code/C/branches/version-0.7@2313 b32b6428-25c9-4566-ad07-03861ab6144f

libxaal_jc/Makefile

@@ -15,7 +15,7 @@ all: lib$(LIB).a lib$(LIB).so $(DEMO)
 lib$(LIB).a: lib$(LIB).o
 	$(AR) rc $@ $^
 	
-lib$(LIB).so: lib$(LIB).c cencode.c cdecode.c
+lib$(LIB).so: lib$(LIB).c
 	$(CC) $(CFLAGS) $^ $(LDFLAGS) -fPIC -shared -o $@
 
 clean:

libxaal_jc/Makefile.dep

-libxaal_jc.o: libxaal_jc.c cencode.h cdecode.h xaal.h xaal_jc.h
+libxaal_jc.o: libxaal_jc.c xaal.h xaal_jc.h
 xaal_jc.o: xaal_jc.c xaal_jc.h

libxaal_jc/cdecode.c

-/*
-cdecoder.c - c source to a base64 decoding algorithm implementation
-
-This is part of the libb64 project, and has been placed in the public domain.
-For details, see http://sourceforge.net/projects/libb64
-*/
-
-#include "cdecode.h"
-
-int base64_decode_value(char value_in)
-{
-	static const char decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
-	static const char decoding_size = sizeof(decoding);
-	value_in -= 43;
-	if (value_in < 0 || value_in > decoding_size) return -1;
-	return decoding[(int)value_in];
-}
-
-void base64_init_decodestate(base64_decodestate* state_in)
-{
-	state_in->step = step_a;
-	state_in->plainchar = 0;
-}
-
-int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in)
-{
-	const char* codechar = code_in;
-	char* plainchar = plaintext_out;
-	char fragment;
-	
-	*plainchar = state_in->plainchar;
-	
-	switch (state_in->step)
-	{
-		while (1)
-		{
-	case step_a:
-			do {
-				if (codechar == code_in+length_in)
-				{
-					state_in->step = step_a;
-					state_in->plainchar = *plainchar;
-					return plainchar - plaintext_out;
-				}
-				fragment = (char)base64_decode_value(*codechar++);
-			} while (fragment < 0);
-			*plainchar    = (fragment & 0x03f) << 2;
-	case step_b:
-			do {
-				if (codechar == code_in+length_in)
-				{
-					state_in->step = step_b;
-					state_in->plainchar = *plainchar;
-					return plainchar - plaintext_out;
-				}
-				fragment = (char)base64_decode_value(*codechar++);
-			} while (fragment < 0);
-			*plainchar++ |= (fragment & 0x030) >> 4;
-			*plainchar    = (fragment & 0x00f) << 4;
-	case step_c:
-			do {
-				if (codechar == code_in+length_in)
-				{
-					state_in->step = step_c;
-					state_in->plainchar = *plainchar;
-					return plainchar - plaintext_out;
-				}
-				fragment = (char)base64_decode_value(*codechar++);
-			} while (fragment < 0);
-			*plainchar++ |= (fragment & 0x03c) >> 2;
-			*plainchar    = (fragment & 0x003) << 6;
-	case step_d:
-			do {
-				if (codechar == code_in+length_in)
-				{
-					state_in->step = step_d;
-					state_in->plainchar = *plainchar;
-					return plainchar - plaintext_out;
-				}
-				fragment = (char)base64_decode_value(*codechar++);
-			} while (fragment < 0);
-			*plainchar++   |= (fragment & 0x03f);
-		}
-	}
-	/* control should not reach here */
-	return plainchar - plaintext_out;
-}

libxaal_jc/cdecode.h

-/*
-cdecode.h - c header for a base64 decoding algorithm
-
-This is part of the libb64 project, and has been placed in the public domain.
-For details, see http://sourceforge.net/projects/libb64
-*/
-
-#ifndef BASE64_CDECODE_H
-#define BASE64_CDECODE_H
-
-typedef enum
-{
-	step_a, step_b, step_c, step_d
-} base64_decodestep;
-
-typedef struct
-{
-	base64_decodestep step;
-	char plainchar;
-} base64_decodestate;
-
-void base64_init_decodestate(base64_decodestate* state_in);
-
-int base64_decode_value(char value_in);
-
-int base64_decode_block(const char* code_in, const int length_in, char* plaintext_out, base64_decodestate* state_in);
-
-#endif /* BASE64_CDECODE_H */

libxaal_jc/cencode.c

-/*
-  Note: Modifications to avoid line break
-*/
-
-/*
-cencoder.c - c source to a base64 encoding algorithm implementation
-
-This is part of the libb64 project, and has been placed in the public domain.
-For details, see http://sourceforge.net/projects/libb64
-*/
-
-#include "cencode.h"
-
-//const int CHARS_PER_LINE = 72;
-
-void base64_init_encodestate(base64_encodestate* state_in)
-{
-	state_in->step = step_A;
-	state_in->result = 0;
-	//state_in->stepcount = 0;
-}
-
-char base64_encode_value(char value_in)
-{
-	static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-	if (value_in > 63) return '=';
-	return encoding[(int)value_in];
-}
-
-int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in)
-{
-	const char* plainchar = plaintext_in;
-	const char* const plaintextend = plaintext_in + length_in;
-	char* codechar = code_out;
-	char result;
-	char fragment;
-	
-	result = state_in->result;
-	
-	switch (state_in->step)
-	{
-		while (1)
-		{
-	case step_A:
-			if (plainchar == plaintextend)
-			{
-				state_in->result = result;
-				state_in->step = step_A;
-				return codechar - code_out;
-			}
-			fragment = *plainchar++;
-			result = (fragment & 0x0fc) >> 2;
-			*codechar++ = base64_encode_value(result);
-			result = (fragment & 0x003) << 4;
-	case step_B:
-			if (plainchar == plaintextend)
-			{
-				state_in->result = result;
-				state_in->step = step_B;
-				return codechar - code_out;
-			}
-			fragment = *plainchar++;
-			result |= (fragment & 0x0f0) >> 4;
-			*codechar++ = base64_encode_value(result);
-			result = (fragment & 0x00f) << 2;
-	case step_C:
-			if (plainchar == plaintextend)
-			{
-				state_in->result = result;
-				state_in->step = step_C;
-				return codechar - code_out;
-			}
-			fragment = *plainchar++;
-			result |= (fragment & 0x0c0) >> 6;
-			*codechar++ = base64_encode_value(result);
-			result  = (fragment & 0x03f) >> 0;
-			*codechar++ = base64_encode_value(result);
-			
-			//++(state_in->stepcount);
-			//if (state_in->stepcount == CHARS_PER_LINE/4)
-			//{
-			//	*codechar++ = '\n';
-			//	state_in->stepcount = 0;
-			//}
-		}
-	}
-	/* control should not reach here */
-	return codechar - code_out;
-}
-
-int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
-{
-	char* codechar = code_out;
-	
-	switch (state_in->step)
-	{
-	case step_B:
-		*codechar++ = base64_encode_value(state_in->result);
-		*codechar++ = '=';
-		*codechar++ = '=';
-		break;
-	case step_C:
-		*codechar++ = base64_encode_value(state_in->result);
-		*codechar++ = '=';
-		break;
-	case step_A:
-		break;
-	}
-	//*codechar++ = '\n';
-	*codechar++ = '\0';
-	
-	return codechar - code_out;
-}

libxaal_jc/cencode.h

-/*
-cencode.h - c header for a base64 encoding algorithm
-
-This is part of the libb64 project, and has been placed in the public domain.
-For details, see http://sourceforge.net/projects/libb64
-*/
-
-#ifndef BASE64_CENCODE_H
-#define BASE64_CENCODE_H
-
-typedef enum
-{
-	step_A, step_B, step_C
-} base64_encodestep;
-
-typedef struct
-{
-	base64_encodestep step;
-	char result;
-	int stepcount;
-} base64_encodestate;
-
-void base64_init_encodestate(base64_encodestate* state_in);
-
-char base64_encode_value(char value_in);
-
-int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in);
-
-int base64_encode_blockend(char* code_out, base64_encodestate* state_in);
-
-#endif /* BASE64_CENCODE_H */

libxaal_jc/libxaal_jc.c

 /* libxaal_jc
  * Auxiliary json2cbor & cbor2json transcoders for xAAL
  *
- * (c) 2017 Christophe Lohr <christophe.lohr@imt-atlantique.fr>
+ * (c) 2019 Christophe Lohr <christophe.lohr@imt-atlantique.fr>
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as published by
@@ -22,8 +22,6 @@
 #include <cbor.h>
 #include <json-c/json.h>
 #include <uuid/uuid.h>
-#include "cencode.h"
-#include "cdecode.h"
 
 #include <xaal.h>
 #include <xaal_jc.h>
@@ -50,20 +48,11 @@ json_object *xAAL_bytestring2json(cbor_item_t *item) {
     return json_object_new_string(uuid);
 
   } else {
-    json_object *jobj;
-    base64_encodestate b64_state;
-    char *b64;
-    int b64_len;
-
-    b64_len = ((len+2)/3)*4+1;
-    b64 = malloc(b64_len);
-    base64_init_encodestate(&b64_state);
-    b64_len = base64_encode_block((const char *)bstr, len, b64, &b64_state);
-    b64_len += base64_encode_blockend(b64+b64_len, &b64_state);
+    char hex[len*2];
+    for (size_t i = 0; i<len; i++)
+      sprintf(&(hex[2*i]), "%02x", bstr[i]);
     free(bstr);
-    jobj = json_object_new_string_len(b64, b64_len);
-    free(b64);
-    return jobj;
+    return json_object_new_string_len(hex, len*2);;
   }
 }
 
@@ -152,18 +141,6 @@ cbor_item_t *xAAL_jsonstring2cbor(json_object *jobj) {
 }
 
 
-cbor_item_t *xAAL_jsonb64_to_bytestring(json_object *jobj) {
-  const char *str = json_object_get_string(jobj);
-  int sz, len = json_object_get_string_len(jobj);
-  base64_decodestate b64_state;
-  char b64[ ((len+1)*6)/8 ];
-
-  base64_init_decodestate(&b64_state);
-  sz = base64_decode_block(str, len, b64, &b64_state);
-  return cbor_build_stringn(b64, sz);
-}
-
-
 cbor_item_t *xAAL_json2cbor_ex(json_object *jobj, unsigned maxdepth) {
   if (!maxdepth--)
     return cbor_new_undef();

libxaal_jc/xaal_jc.h

@@ -21,7 +21,7 @@
 #ifndef LIBXAAL_JC
 #define LIBXAAL_JC
 
-#define xAAL_JC_VERSION	"0.1"
+#define xAAL_JC_VERSION	"0.2"
 
 #include <cbor.h>
 #include <json-c/json.h>
@@ -30,9 +30,8 @@
  * cbor2json
  */
 
-/* Transcode a cbor bytestring into json string
- * Note: bytestring[16] are encoded as uuid,
- * other data are base64 encoded */
+/* Transcode a cbor bytestring into json string, with hexadecimal notation
+ * Except bytestring[16] that are encoded as uuid (i.e. hexa with dash) */
 json_object *xAAL_bytestring2json(cbor_item_t *item);
 
 /* Do its best to transcode cbor data into json