packet fragmentation for raw sockets

If I am using raw sockets to send a UDP packet of size 3000bytes, do 开发者_如何学编程I need to handle packet fragmentation myself in the code, or should the raw socket handle fragmentation similar to DGRAM socket?

Well, if you are using UDP, you aren't really sending RAW. RAW would be no IP at all, in which case yes you have to handle fragmentation yourself.

With UDP you get IP's fragmentation support, which is IMHO plenty good enough for short-haul networks where collisions should be minimal. Make the link between the two systems a dedicated subnet, and it isn't an issue at all.

What TCP buys you over UDP (among other things) is the stack's ability to just have to resend one fragment if it gets lost or hosed somehow. With UDP if that happens the entire message must be discarded. There's overhead with that though, and for most modern networks you can probably live with that trade-off.

Nope, packet fragmentation is handled at a lower level. You should see exactly what you put in the packet come back out. That is to say UDP guaranties message boundaries.

The underlying protocol, IP, still handles fragmentation. As long as you're not setting the DF (don't fragment) bit you should be fine, I think.

Depending on your system this can be handled quite differently. For example on Linux you can ask the lower layers to handle path MTU discovery and give an error (EMSGSIZE) if you try and send something larger than the (known) path MTU.

How "raw" is the raw socket you're talking about? Other systems could just let you control the DF bit (or you might be constructing most of the IP header yourself) in which case the behaviour will also depend on this.

As a rule if you transmit with DF set you will usually get a choice of seeing an error in userspace, or having the lower levels on your host handle PMTU discovery and stopping you sending something too large. If you don't set DF then you (probably) will see appropriate fragmentation from router(s) along the path.

For Linux, the answer is yes. If you take a look at Linux's raw socket implementation, there is no reassembly happening for raw sockets.

Yes, SOCK_RAW dont handle Fragmentation and reassembly. RAW socket treated your complete data buffer is treated as L2 protocol's data/payload, and it doesn't know about L3 and above.

In case of SOCK_DGRAM or SOCK_STREAM, your data buffer will be treated as data/payload to L4 protocols. so L3 handling(frag/reass) will done by linux stack.