How do I safely cast a void* to an int in C?

Question

Or maybe, I shouldn't cast. Here's what I'm doing:

I'm writing a piece of code that links a Linux device driver to a higher level library. The authors of the library use void * (under a new name via typedef) to store handles to an implementation specific object that describes a communication channel.

The driver I want to connect with the library uses int to store handles to its channels (because they are file descriptors as returned by calls to open()). So, in my code, I get void * passed in from the library and need to call stuff from the driver using an int and vice versa. I. e.:

// somewhere in the library ...
typedef void* CAN_HANDLE;

// ... in my code
CAN_HANDLE canOpen_driver(s_BOARD *board)
{
  int fd;
  // ...
  fd = open(busname, O_RDWR);
  // ...
  return (CAN_HANDLE) fd; // <-- not safe, especially not when converting back.
}

The adapters that others have written actually store some struct etc. somewhere and just cast between pointers, so no size issues arise. In my case, I don't really want to manage file descriptors, as the OS already does.

On my PC, I think the pointer is larger than the int, so I could bit-twiddle my way out of this, but the code goes into embedded systems, too, and I'm not experienced enough to make any assumptions about the size of types on those machines.

Seeing the all caps "CAN_HANDLE" made me chuckle in memory of the LOLCODE meme :) Not criticizing your code... — Ates Goral, Feb 07 '11 at 15:46
Yeah, I chuckled too. The library is full of this: can_open, can_send etc. (It's a CAN bus library) :) — Hanno Fietz, Feb 07 '11 at 15:49
`void*` is certainly allowed to be smaller than `int`, although I don't think I've ever seen that. Anyway in practice fds start from 0, and you'll run out out system resources before creating so many fds that an fd-number is too large to store in `void*`. That's not to say this can't be done differently, but personally I don't see it breaking *unless* the system traps on creating invalid pointer values. To be safe, if you can make an allocation of as many chars as your system supports fds, then a pointer to the nth element of that array can represent fd n, avoiding an allocation per fd. — Steve Jessop, Feb 07 '11 at 15:57
This may be irrelevant semantic mumbo-jumbo, but "pointer to void" sounds really weird. "void pointer" sounds okay, but it's just a generic pointer; it doesn't point to void. — William Pursell, Feb 07 '11 at 16:04
"especially not when converting back" Actually, converting back is always safe because it's the same value. — Jim Balter, Feb 08 '11 at 11:37
@William void is a type and so pointer to void is the correct terminology and is used in the C standard. — Jim Balter, Feb 08 '11 at 11:41

score 3 · Accepted Answer · answered Feb 07 '11 at 15:55

3

Edit: Of course you don't need a struct, you can just allocate memory for a plain int.

CAN_HANDLE canOpen_driver(s_BOARD *board)
{
  int *fd = malloc(sizeof(int));
  if (fd)
  {
    // ...
    *fd = open(busname, O_RDWR);
    // ...
    return (CAN_HANDLE) fd;
  } 

  // failure
  return NULL;
}

This assumes there's a matching call to clean up. Something like:

void canClose_driver(CAN_HANDLE handle)
{
  int *fd = handle;
  free(fd);
}

answered Feb 07 '11 at 15:55

Graham Borland

60,055
21
138
179

Yeah, that's what I'm doing now. Meanwhile, I also found this very similar post: http://stackoverflow.com/questions/1327579/if-i-have-a-void-pointer-how-do-i-put-an-int-into-it – Hanno Fietz Feb 07 '11 at 16:26
...and if you ever need to store more than just the file descriptor as private data, you can change from an `int` to `struct`. – caf Feb 08 '11 at 00:38

score 2 · Answer 2 · answered Feb 07 '11 at 15:55

Depending on the architecture, you might get away with that. If I understand correctly, the driver never actually uses the void* that you provide to it. It simply stores it to pass it back to your code later on.

Based on that assumption, as long as sizeof(void*) >= sizeof(int), it will be safe to cast between those types because you are sure that it is really a int.

If you cannot guarantee the size condition, or do not want to rely on a hack, you should allocate memory for the int and return the address of that memory. You might use malloc() or allocate a int in a fixed-size array, for example. The downside is that you will need to free that memory when it is no longer needed. I imagine that the driver has some kind of notification that signals your code when the data structure is no longer needed.

score 0 · Answer 3 · answered Feb 07 '11 at 16:18

Generally on embedded systems, the following CPU models are most common:

Data bus   Address bus   

 8 bit     16 bit  
 8 bit     16+8 bit (banking) 
16 bit     16 bit 
16 bit     16+8 bit (banking) 
32 bit     32 bit

Generally, the address bus will always be >= than the data bus. I can't think of any CPU where the data bus would be larger than the address bus.

Here's a somewhat dirty trick that may or may not solve the issue:

typedef union
{
  CAN_HANDLE  handle;
  long        value;

} CAN_HANDLE_t;

This should be fairly portable, even though you will likely have to adapt this union to the specific system (far pointers etc).

How do I safely cast a void* to an int in C?

3 Answers3