Hi,
yes, getting rid of the endian #defines is one thing.
But the edian things are only used for converting an
unsigned long into a 4-byte array in big-endian notation
and vice versa (+ idem for unsigned shorts) in the
following way:
- swap unsigned long if needed
- memcpy(byte array, &(the unsigned long), 4)
It's nicer/simpler to make a function that does both,
pls. see the attached patch.
Cheers,
Stef
Ludovic Rousseau wrote:
Hello,
On 20/06/06, Andreas Jellinghaus <[EMAIL PROTECTED]> wrote:
hmm, I don't know how the code looks right now or would look after your
change. but I'd prefer to have the code without #ifdef and then have
some define macro or function (maybe inline?) swap bytes around (or
not).
i.e. make the code easy to read and only have the macro/function look
at the endian of the architecture.
I agree.
also I wonder if there are no functions we can use. endian problems are
not new, for example the whole network code has this host to network
conversions etc, so I wonder.
Yes. The network code can use
#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
Also according to the manpage: "On the i80x86 the host byte order is
Least Significant Byte first, whereas the network byte order, as
used on the Internet, is Most Significant Byte first."
So the byte order is swapped on a i386 host. But I needed the reverse
in my CCID code (do not swap on i386 but swap on PowerPC)
According to the code in Stef' mail it should be possible to replace
if (BIG_ENDIAN)
x = bswap_32(x);
by
x = htonl(x);
Bye,
Index: sc.c
===================================================================
--- sc.c (revision 2977)
+++ sc.c (working copy)
@@ -110,6 +110,32 @@
return 0;
}
+void ulong2bebytes(u8 *buf, unsigned long x)
+{
+ buf[3] = (u8) (x % 256);
+ x /= 256;
+ buf[2] = (u8) (x % 256);
+ x /= 256;
+ buf[1] = (u8) (x % 256);
+ buf[0] = (u8) (x / 256);
+}
+
+void ushort2bebytes(u8 *buf, unsigned short x)
+{
+ buf[1] = (u8) (x % 256);
+ buf[0] = (u8) (x / 256);
+}
+
+unsigned long bebytes2ulong(const u8 *buf)
+{
+ return (unsigned long) (256 * (256 * (256 * buf[0] + buf[1]) + buf[2]) +
buf[3]);
+}
+
+unsigned short bebytes2ushort(const u8 *buf)
+{
+ return (unsigned short) (256 * buf[0] + buf[1]);
+}
+
int sc_format_oid(struct sc_object_id *oid, const char *in)
{
int ii, ret = SC_ERROR_INVALID_ARGUMENTS;
Index: muscle.c
===================================================================
--- muscle.c (revision 2977)
+++ muscle.c (working copy)
@@ -41,27 +41,6 @@
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif
-#if defined(_WIN32) || defined(_WIN64)
-static unsigned long bswap_32(unsigned long x)
-{
- unsigned long res = x % 256;
- x /= 256;
- res = 256 * res + x % 256;
- x /= 256;
- res = 256 * res + x % 256;
- x /= 256;
- return 256 * res + x % 256;
-}
-static unsigned short bswap_16(unsigned short x)
-{
- return 256 * (x % 256) + (x / 256);
-}
-#define BIG_ENDIAN 1
-#else
-#include <endian.h>
-#include <byteswap.h>
-#endif
-
int msc_list_objects(sc_card_t* card, u8 next, mscfs_file_t* file) {
sc_apdu_t apdu;
u8 fileData[14];
@@ -89,17 +68,11 @@
return SC_ERROR_UNKNOWN_DATA_RECEIVED;
}
memcpy(file->objectId, fileData, 4);
- file->size = *(int*)(fileData + 4);
- file->read = *(short*)(fileData + 8);
- file->write = *(short*)(fileData + 10);
- file->delete = *(short*)(fileData + 12);
-
- if(BIG_ENDIAN) {
- file->size = bswap_32(file->size);
- file->read = bswap_16(file->read);
- file->write = bswap_16(file->write);
- file->delete = bswap_16(file->delete);
- }
+ file->size = bebytes2ulong(fileData + 4);
+ file->read = bebytes2ushort(fileData + 8);
+ file->write = bebytes2ushort(fileData + 10);
+ file->delete = bebytes2ushort(fileData + 12);
+
return 1;
}
@@ -108,16 +81,13 @@
u8 buffer[9];
sc_apdu_t apdu;
int r;
- unsigned int le_offset = offset;
sc_format_apdu(card, &apdu, SC_APDU_CASE_4_SHORT, 0x56, 0x00, 0x00);
- if(BIG_ENDIAN)
- le_offset = bswap_32(le_offset);
if (card->ctx->debug >= 2)
- sc_debug(card->ctx, "READ: Offset: %x\tLength: %i\n",
le_offset, dataLength);
- memcpy(buffer, &le_objectId, 4);
- memcpy(buffer + 4, &le_offset, 4);
+ sc_debug(card->ctx, "READ: Offset: %x\tLength: %i\n", offset,
dataLength);
+ ulong2bebytes(buffer, le_objectId);
+ ulong2bebytes(buffer + 4, offset);
buffer[8] = (u8)dataLength;
apdu.data = buffer;
apdu.datalen = 9;
@@ -182,21 +152,15 @@
apdu.data = buffer,
apdu.datalen = 14;
- if(BIG_ENDIAN) {
- objectSize = bswap_32(objectSize);
- readAcl = bswap_16(readAcl);
- writeAcl = bswap_16(writeAcl);
- deleteAcl = bswap_16(deleteAcl);
- }
- memcpy(buffer, &objectId, 4);
- memcpy(buffer + 4, &objectSize, 4);
- memcpy(buffer + 8, &readAcl, 2);
- memcpy(buffer + 10, &writeAcl, 2);
- memcpy(buffer + 12, &deleteAcl, 2);
+ ulong2bebytes(buffer, objectId);
+ ulong2bebytes(buffer + 4, objectSize);
+ ushort2bebytes(buffer + 8, readAcl);
+ ushort2bebytes(buffer + 10, writeAcl);
+ ushort2bebytes(buffer + 12, deleteAcl);
r = sc_transmit_apdu(card, &apdu);
SC_TEST_RET(card->ctx, r, "APDU transmit failed");
if(apdu.sw1 == 0x90 && apdu.sw2 == 0x00)
- return BIG_ENDIAN ? bswap_32(objectSize) : objectSize;
+ return objectSize;
if(apdu.sw1 == 0x9C) {
if(apdu.sw2 == 0x01) {
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_MEMORY_FAILURE);
@@ -210,8 +174,8 @@
sc_debug(card->ctx, "got strange SWs: 0x%02X 0x%02X\n",
apdu.sw1, apdu.sw2);
}
- msc_zero_object(card, objectId, BIG_ENDIAN ? bswap_32(objectSize) :
objectSize);
- return BIG_ENDIAN ? bswap_32(objectSize) : objectSize;
+ msc_zero_object(card, objectId, objectSize);
+ return objectSize;
}
/* Update up to 246 bytes */
@@ -219,18 +183,14 @@
{
u8 buffer[256];
sc_apdu_t apdu;
- unsigned int le_offset;
int r;
sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0x54, 0x00, 0x00);
apdu.lc = dataLength + 9;
- le_offset = offset;
- if(BIG_ENDIAN)
- le_offset = bswap_32(le_offset);
if (card->ctx->debug >= 2)
- sc_debug(card->ctx, "WRITE: Offset: %x\tLength: %i\n",
le_offset, dataLength);
- memcpy(buffer, &le_objectId, 4);
- memcpy(buffer + 4, &le_offset, 4);
+ sc_debug(card->ctx, "WRITE: Offset: %x\tLength: %i\n", offset,
dataLength);
+ ulong2bebytes(buffer, le_objectId);
+ ulong2bebytes(buffer + 4, offset);
buffer[8] = (u8)dataLength;
memcpy(buffer + 9, data, dataLength);
apdu.data = buffer;
@@ -270,11 +230,13 @@
int msc_delete_object(sc_card_t *card, unsigned int objectId, int zero)
{
sc_apdu_t apdu;
+ u8 buf[4];
int r;
sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0x52, 0x00, zero ?
0x01 : 0x00);
apdu.lc = 4;
- apdu.data = (u8*)&objectId;
+ ulong2bebytes(buf, objectId);
+ apdu.data = buf;
apdu.datalen = 4;
r = sc_transmit_apdu(card, &apdu);
SC_TEST_RET(card->ctx, r, "APDU transmit failed");
@@ -434,8 +396,6 @@
{
sc_apdu_t apdu;
int r, location, cse, len;
- short dataLength_le = dataLength;
- short seedLength_le = seedLength;
u8 *buffer, *ptr;
location = (dataLength < 255) ? 1 : 2; /* 1 == APDU, 2 == (seed in
0xFFFFFFFE, out in 0xFFFFFFFF) */
@@ -444,17 +404,13 @@
assert(seedLength < 251);
assert(dataLength < 255); /* Output buffer doesn't seem to operate as
desired.... nobody can read/delete */
- if(BIG_ENDIAN) {
- dataLength_le = bswap_16(dataLength_le);
- seedLength_le = bswap_16(seedLength_le);
- }
buffer = malloc(len);
if(!buffer) SC_FUNC_RETURN(card->ctx, 0, SC_ERROR_OUT_OF_MEMORY);
ptr = buffer;
- memcpy(ptr, &dataLength_le, 2);
+ ushort2bebytes(ptr, dataLength);
ptr+=2;
- memcpy(ptr, &seedLength_le, 2);
+ ushort2bebytes(ptr, seedLength);
ptr+=2;
if(seedLength > 0) {
memcpy(ptr, seedData, seedLength);
@@ -524,32 +480,24 @@
assert(privateKey <= 0x0F && publicKey <= 0x0F);
sc_format_apdu(card, &apdu, SC_APDU_CASE_3_SHORT, 0x30, privateKey,
publicKey);
- if(BIG_ENDIAN) {
- keySize = bswap_16(keySize);
- prRead = bswap_16(prRead);
- prWrite = bswap_16(prWrite);
- prCompute = bswap_16(prCompute);
- puRead = bswap_16(puRead);
- puWrite = bswap_16(puWrite);
- puCompute = bswap_16(puCompute);
- }
+
*ptr = algorithm; ptr++;
- memcpy(ptr, &keySize, 2);
+ ushort2bebytes(ptr, keySize);
ptr+=2;
- memcpy(ptr, &prRead, 2);
+ ushort2bebytes(ptr, prRead);
ptr+=2;
- memcpy(ptr, &prWrite, 2);
+ ushort2bebytes(ptr, prWrite);
ptr+=2;
- memcpy(ptr, &prCompute, 2);
+ ushort2bebytes(ptr, prCompute);
ptr+=2;
- memcpy(ptr, &puRead, 2);
+ ushort2bebytes(ptr, puRead);
ptr+=2;
- memcpy(ptr, &puWrite, 2);
+ ushort2bebytes(ptr, puWrite);
ptr+=2;
- memcpy(ptr, &puCompute, 2);
+ ushort2bebytes(ptr, puCompute);
ptr+=2;
*ptr = 0; /* options; -- no options for now, they need extra data */
@@ -870,8 +818,7 @@
/* USED IN KEY ITEM WRITING */
#define CPYVAL(valName) \
- length = BIG_ENDIAN ? bswap_16(data->valName ## Length) : data->valName
## Length; \
- memcpy(p, &length, 2); p+= 2; \
+ ushort2bebytes(p, data->valName ## Length); p+= 2; \
memcpy(p, data->valName ## Value, data->valName ## Length); p+=
data->valName ## Length
int msc_import_key(sc_card_t *card,
@@ -905,13 +852,6 @@
SC_FUNC_RETURN(card->ctx, 2, SC_ERROR_INVALID_ARGUMENTS)
}
- if(BIG_ENDIAN) {
- read = bswap_16(read);
- write = bswap_16(write);
- use = bswap_16(use);
- keySize = bswap_16(keySize);
- }
-
if(data->keyType == 0x02) {
bufferSize = 4 + 4 + data->pLength + data->modLength;
} else if(data->keyType == 0x03) {
@@ -924,14 +864,12 @@
p = buffer;
*p = 0x00; p++; /* Encoding plain */
*p = data->keyType; p++; /* RSA_PRIVATE */
- memcpy(p, &keySize, 2); p+=2; /* key size */
+ ushort2bebytes(p, keySize); p+=2; /* key size */
if(data->keyType == 0x02) {
- unsigned int length;
CPYVAL(mod);
CPYVAL(p);
} else if(data->keyType == 0x03) {
- unsigned int length;
CPYVAL(p);
CPYVAL(q);
CPYVAL(pq);
@@ -939,9 +877,7 @@
CPYVAL(dq1);
}
objectId = 0xFFFFFFFEul;
- if(BIG_ENDIAN) {
- objectId = bswap_32(objectId);
- }
+
r = msc_create_object(card, objectId, bufferSize, 0x02, 0x02, 0x02);
if(r < 0) {
if(r == SC_ERROR_FILE_ALREADY_EXISTS) {
@@ -967,9 +903,9 @@
apdu.data = apduBuffer;
apdu.datalen = 6;
p = apduBuffer;
- memcpy(p, &read, 2); p+=2;
- memcpy(p, &write, 2); p+=2;
- memcpy(p, &use, 2); p+=2;
+ ushort2bebytes(p, read); p+=2;
+ ushort2bebytes(p, write); p+=2;
+ ushort2bebytes(p, use); p+=2;
r = sc_transmit_apdu(card, &apdu);
SC_TEST_RET(card->ctx, r, "APDU transmit failed");
if(apdu.sw1 == 0x90 && apdu.sw2 == 0x00) {
Index: card-muscle.c
===================================================================
--- card-muscle.c (revision 2977)
+++ card-muscle.c (working copy)
@@ -137,7 +137,7 @@
objectSize = file->size;
muscle_parse_acls(file, &read, &write, &delete);
- r = msc_create_object(card, *(int*)objectId, objectSize, read, write,
delete);
+ r = msc_create_object(card, bebytes2ulong(objectId), objectSize, read,
write, delete);
mscfs_clear_cache(fs);
if(r >= 0) return 0;
return r;
@@ -183,7 +183,7 @@
objectId[1] = objectId[3];
objectId[2] = objectId[3] = 0;
}
- r = msc_read_object(card, *(int*)objectId, index, buf, count);
+ r = msc_read_object(card, bebytes2ulong(objectId), index, buf, count);
SC_FUNC_RETURN(card->ctx, 0, r);
}
@@ -209,22 +209,22 @@
u8* buffer = malloc(newFileSize);
if(buffer == NULL) SC_FUNC_RETURN(card->ctx, 0,
SC_ERROR_OUT_OF_MEMORY);
- r = msc_read_object(card, *(int*)objectId, 0, buffer,
file->size);
+ r = msc_read_object(card, bebytes2ulong(objectId), 0, buffer,
file->size);
/* TODO: RETREIVE ACLS */
if(r < 0) goto update_bin_free_buffer;
- r = msc_delete_object(card, *(int*)objectId, 0);
+ r = msc_delete_object(card, bebytes2ulong(objectId), 0);
if(r < 0) goto update_bin_free_buffer;
- r = msc_create_object(card, *(int*)objectId, newFileSize,
0,0,0);
+ r = msc_create_object(card, bebytes2ulong(objectId),
newFileSize, 0,0,0);
if(r < 0) goto update_bin_free_buffer;
memcpy(buffer + index, buf, count);
- r = msc_update_object(card, *(int*)objectId, 0, buffer,
newFileSize);
+ r = msc_update_object(card, bebytes2ulong(objectId), 0, buffer,
newFileSize);
if(r < 0) goto update_bin_free_buffer;
file->size = newFileSize;
update_bin_free_buffer:
free(buffer);
SC_FUNC_RETURN(card->ctx, 0, r);
} else {
- r = msc_update_object(card, *(int*)objectId, index, buf, count);
+ r = msc_update_object(card, bebytes2ulong(objectId), index,
buf, count);
}
//mscfs_clear_cache(fs);
return r;
@@ -234,7 +234,7 @@
{
mscfs_t *fs = MUSCLE_FS(card);
u8 *id = file_data->objectId;
- int objectId = *(int*)id;
+ int objectId = bebytes2ulong(id);
int r;
if(!file_data->ef) {
Index: muscle-filesystem.h
===================================================================
--- muscle-filesystem.h (revision 2977)
+++ muscle-filesystem.h (working copy)
@@ -63,5 +63,4 @@
int mscfs_check_selection(mscfs_t *fs, int requiredItem);
int mscfs_loadFileInfo(mscfs_t* fs, const u8 *path, int pathlen, mscfs_file_t
**file_data, int* index);
-
#endif
Index: opensc.h
===================================================================
--- opensc.h (revision 2977)
+++ opensc.h (working copy)
@@ -1081,6 +1081,16 @@
int sc_hex_to_bin(const char *in, u8 *out, size_t *outlen);
int sc_bin_to_hex(const u8 *, size_t, char *, size_t, int separator);
+
+/* unsigned long -> 4 bytes in big endian order */
+void ulong2bebytes(u8 *buf, unsigned long x);
+/* unsigned short -> 2 bytes in big endian order */
+void ushort2bebytes(u8 *buf, unsigned short x);
+/* 4 bytes in big endian order -> unsigned long */
+unsigned long bebytes2ulong(const u8 *buf);
+/* 2 bytes in big endian order -> unsigned long */
+unsigned short bebytes2ushort(const u8 *buf);
+
scconf_block *sc_get_conf_block(sc_context_t *ctx, const char *name1, const
char *name2, int priority);
/**
* Converts a given OID in ascii form to a internal sc_object_id object
_______________________________________________
opensc-devel mailing list
opensc-devel@lists.opensc-project.org
http://www.opensc-project.org/mailman/listinfo/opensc-devel
