Convert char[] to off_t

Question

I stored a filesize in a binary file and I am able to get this filesize into a char[8] buffer. I would like to convert this char[] into an off_t type in order to be able to pass it as an argument of truncate(const char *path, off_t length).

I tried this naive approach and it seems to work most of the time, but it fails sometimes and gives me a weird sequence of bits.

off_t pchar_2_off_t(char* str, size_t size)
{
    off_t ret = 0;
    size_t i;
    for (i = 0; i < size; ++i)
    {
        ret <<= 8;
        ret |= str[i];
    }
    return ret;
}

Convert the `str[i]` to some sort of unsigned: `ret |= (unsigned)str[i];` — pmg, Feb 07 '15 at 15:14
Do you know if your compilers `char` type is signed or unsigned? That may have something to do with it, as may the actual *writing* to the file. — Some programmer dude, Feb 07 '15 at 15:14
@user1527491: `ret |= (unsigned char)str[i];`. The `str[i]` is promoted to `int` before the cast. — mafso, Feb 07 '15 at 15:22
Alternatively, use `unsigned char` everywhere (also for the array) from the beginning. IMO, the more appropriate type anyway — mafso, Feb 07 '15 at 15:24

score 1 · Answer 1 · edited May 23 '17 at 11:57

1

Just bulk-copy the data in question:

#include <string.h> /* for memcpy() */

...

char str[8];
/* Read 8 bytes binary data into str here. */

off_t off_file;
memcpy(&off_file, str, sizeof off_file);

To get around any endiness issues just do:

off_t off = ntohll(off_file); /* Assuming ntohll being the 64bit version of ntohl(). */

As ntohll() is non-standard please see some possible ways to implement it here: 64 bit ntohl() in C++?

edited May 23 '17 at 11:57

Community

1
1

answered Feb 07 '15 at 15:33

alk

69,737
10
105
255

Why should it be any better than a cast (user59002 answer)? It's longer to type and slower. – Adam Sosnowski Feb 07 '15 at 15:42
@user36740: I did not say it is better or worth then anything. – alk Feb 07 '15 at 15:45
this has an endianness problem. – Grady Player Feb 07 '15 at 15:45
1

This approach assumes the same endian of `str` in the file as in `off` - which is reasonable. OP's approach only assumes `str` endian. – chux - Reinstate Monica Feb 07 '15 at 15:46
@GradyPlayer: This has not more an endiness issue then casting pointers, before deferencing one and using the assignment operator. – alk Feb 07 '15 at 15:46
yeah that is wrong too, and if I could comment more than once every 15 seconds I would have made that comment. – Grady Player Feb 07 '15 at 15:47
Why? @GradyPlayer The members of the ntoh/hton family of functions only convert if necessary. That is is host-byte-order and network-byte-order are different, else they are noops. – alk Feb 07 '15 at 16:02
alright, your imaginary function erases my down vote – Grady Player Feb 07 '15 at 16:13

score 1 · Accepted Answer · edited May 23 '17 at 12:12

1

ret |= str[i]; is a problem as str[i] may sign-extend upon conversion to int, setting many bits in ret. Implied by @pmg and commented by @mafso

off_t pchar_2_off_t(const char* str, size_t size) {
    off_t ret = 0;
    size_t i;
    for (i = 0; i < size; ++i) {
        ret <<= 8;
        ret |= (unsigned char) str[i];
    }
    return ret;
}

edited May 23 '17 at 12:12

Community

1
1

answered Feb 07 '15 at 15:51

chux - Reinstate Monica

143,097
13
135
256

2

Note: a more pedantic solution would use `ret <<= CHAR_BIT;` as `char` width is not always 8 bits. Seeing how OP saved `str` would clarify details. – chux - Reinstate Monica Feb 07 '15 at 16:06

Grady Player · Answer 3 · 2015-02-07T15:57:37.130

0

unsigned const char blah[8] = {0xdd,0xee,0xaa,0xdd,0xbb,0xee,0xee,0xff};
off_t * scalar = (off_t *) malloc(8);
memcpy(scalar, blah, 8);

printf("%llx\n",*scalar);

outputs(on my intel machine): ffeeeebbddaaeedd

what the wha?! you say.... there is a problem with this approach, and it is that it isn't portable ... it is a problem with endianness ...

so if you want to do this portably you need to actually either be aware of endianness and special case it or just convert with a loop:

*scalar = 0;
for (int i = 0; i < 8; i++)
{
    *scalar += (uint64_t)blah[i] << ( 8 * (7-i));
}

printf("%llx\n",*scalar);

outputs (on all machines that have 64bit off_t's): ddeeaaddbbeeeeff

edited Feb 07 '15 at 15:57

answered Feb 07 '15 at 15:44

Grady Player

14,399
2
48
76

This has an alignment issue. `scalar` may be more restrictive than `blah`. – chux - Reinstate Monica Feb 07 '15 at 15:47
Minor: As the size of `off_t` is not necessarily the same as `unsigned long long`, using `printf("%llx\n",(unsigned long long) *scalar);` is portable. Also `off_t` is signed. – chux - Reinstate Monica Feb 07 '15 at 16:00
If you do not know the endianess the data had been stored with, you have **no** 100% chance to correctly read the data. – alk Feb 07 '15 at 16:00
@alk ... there is an order for elements in an array, and there is an order for most significant bytes in a scalar value... in a big endian machine these are inter changeable; on a little endian machine it isn't... – Grady Player Feb 07 '15 at 16:04

user590028 · Answer 4 · 2015-02-07T15:40:49.593

-1

Assuming the file that contains the filesize was created on the EXACT same machine AND that it was originally written with an off_t type, you can just cast the char[] -> an off_t. eg:

off_t filesize = *((off_t*)str);

edited Feb 07 '15 at 15:40

answered Feb 07 '15 at 15:20

user590028

11,364
3
40
57

1

You probably meant `... = *((off_t *) str);`? – alk Feb 07 '15 at 15:31
If you also now would adjust your wording accordingly, this would be a valid answer ... you aren't casting to `off_t` but to `off_t *`. – alk Feb 07 '15 at 15:42

Convert char[] to off_t

4 Answers4