I'm starting work on a peer-to-peer application that needs to understand a number of protocols including SIP, RTCP, RTP, etc. I don't want to write a parser for each of these. Is there a generic approach/library for parsing a packet and exposing its fields to the rest of your application?

For example you get an SIP packet:
I have not yet found decent libraries (C, C++, Python) that will take this packet, and

1. Recognize the protocol type.
2. Parse the fields and fill up a data structure. It should be a collection or associative array so that you can access the fields by name. (To, From, CSeq, etc.)
3. Call an appropriate handler based on protocol type, and hand it the data structure.

To make this approach useful as possible, it should also provide a generic means to define the protocols using simple text (field names, field data types and the parsing rules). That way you could feed various protocol definitions to your parser, without adding extra code for each one.

Am I running in the wrong direction here? If it doesn't exist, could such a library/object be useful?

To me, it sounds like you are trying to write a subset of a network packet analyzer. So, one approach might be to start out with a complete packet analyzer such as ethereal, and take out the parts you don't want. I don't know of any generic library that provides the services you are looking for. If one exists, I'd be interested in knowing about it.

--- rod.

Actually if you are going to write a p2p *application*, then it is sockets that you are going to use not packet capturing, the socket will handle the lower layers - till transpor - and you will have to find a library to handle the application layer parsing, for example there is libosip for parsing SIP.

I agree that packet capturing is not on the agenda. It's the application layer that I'm interested in.

SIP might have been a poor example, because there's a lot more going on than parsing: you need to conduct several transactions to make thing happen, something a protocol-specific library can do for you. But specifically for things like RTP, RTCP and SDP, it seems to me that parsing the packet fields is a repetitive task that should be made generic across protocols.