1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#ifndef PACKETPP_SDP_LAYER
#define PACKETPP_SDP_LAYER
#include "IpAddress.h"
#include "TextBasedProtocol.h"
#include <vector>
/// @file
/**
* \namespace pcpp
* \brief The main namespace for the PcapPlusPlus lib
*/
namespace pcpp
{
/** Protocol version (v) */
#define PCPP_SDP_PROTOCOL_VERSION_FIELD "v"
/** Originator and session identifier (o) */
#define PCPP_SDP_ORIGINATOR_FIELD "o"
/** Session name (s) */
#define PCPP_SDP_SESSION_NAME_FIELD "s"
/** Session title, media title or short information (i) */
#define PCPP_SDP_INFO_FIELD "i"
/** URI of description (u) */
#define PCPP_SDP_URI_FIELD "u"
/** Email address with optional name of contacts (e) */
#define PCPP_SDP_EMAIL_FIELD "e"
/** Phone number with optional name of contacts (p) */
#define PCPP_SDP_PHONE_FIELD "p"
/** Connection information (c) */
#define PCPP_SDP_CONNECTION_INFO_FIELD "c"
/** Bandwidth information (b) */
#define PCPP_SDP_BANDWIDTH_FIELD "b"
/** Time the session is active (t) */
#define PCPP_SDP_TIME_FIELD "t"
/** Repeat times (r) */
#define PCPP_SDP_REPEAT_TIMES_FIELD "r"
/** Time zone adjustments (z) */
#define PCPP_SDP_TIME_ZONE_FIELD "z"
/** Encryption key (k) */
#define PCPP_SDP_ENCRYPTION_KEY_FIELD "k"
/** Media attribute (a) */
#define PCPP_SDP_MEDIA_ATTRIBUTE_FIELD "a"
/** Media name and transport address (m) */
#define PCPP_SDP_MEDIA_NAME_FIELD "m"
/**
* @class SdpLayer
* Represents a SDP (Session Description Protocol) message. SDP is a text-based protocol described by a series of fields, one per line (lines are separated by CRLF).
* The form of each field is as follows:<BR>
* @code
* [character]=[value]
* @endcode
* Each character represents a certain type of field. All field type are represented as macros in SdpLayer.h file
* (for example: PCPP_SDP_ORIGINATOR_FIELD is a macro for the originator field (o=) ).<BR>
* For more details about SDP structure please refer to its Wikipedia page: https://en.wikipedia.org/wiki/Session_Description_Protocol
*/
class SdpLayer : public TextBasedProtocolMessage
{
public:
/** A constructor that creates the layer from an existing packet raw data
* @param[in] data A pointer to the raw data
* @param[in] dataLen Size of the data in bytes
* @param[in] prevLayer A pointer to the previous layer
* @param[in] packet A pointer to the Packet instance where layer will be stored in
*/
SdpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
/**
* An empty c'tor which initialize an empty message with no fields
*/
SdpLayer();
/**
* A c'tor which initializes a message with the minimum required fields.<BR>
* After this c'tor the message will look like this:
*
* @code
* v=0
* o=[username] [sessionID] [sessionVersion] IN IP4 [ipAddress]
* s=[sessionName]
* c=IN IP4 [ipAddress]
* t=[startTime] [endTime]
* @endcode
*
* @param[in] username User's login on the originating host
* @param[in] sessionID A globally unique identifier for the session
* @param[in] sessionVersion A version number for this session description
* @param[in] ipAddress The address of the machine from which the session is created
* @param[in] sessionName A textual session name
* @param[in] startTime The start time of the session
* @param[in] stopTime The stop time of the session
*/
SdpLayer(const std::string& username, long sessionID, long sessionVersion, IPv4Address ipAddress, const std::string& sessionName, long startTime, long stopTime);
~SdpLayer() {}
/**
* A copy constructor for this layer. Inherits the base copy constructor and doesn't add
* anything else
* @param[in] other The instance to copy from
*/
SdpLayer(const SdpLayer& other) : TextBasedProtocolMessage(other) {}
/**
* An assignment operator overload for this layer. Inherits the base assignment operator
* and doesn't add anything else
* @param[in] other The instance to copy from
*/
SdpLayer& operator=(const SdpLayer& other) { TextBasedProtocolMessage::operator=(other); return *this; }
/**
* The 'originator' field (o=) contains the IP address of the the machine from which the session is created.
* This IP address can be used to track the RTP data relevant for the call. This method extracts this IP address from the 'originator' field and returns it.
* A value of IPv4Address#Zero will be returned in the following cases: (1) if 'originator' field doesn't exist; (2) if it doesn't contain the IP address;
* (3) if it contains a non-IPv4 address
* @return The IP address of the the machine from which the session is created
*/
IPv4Address getOwnerIPv4Address() const;
/**
* The 'media-description' field (m=) contains the transport port to which the media stream is sent. This port can be used to track the RTP data relevant for the call.
* This method extracts this port from the 'media-description' field and returns it. Since a SDP message can contain several 'media-description' fields, one for each media type
* (e.g audio, image, etc.), the user is required to provide the media type. A value of 0 will be returned in the following cases: (1) if 'media-description' field doesn't
* exist; (2) if provided media type was not found; (3) if 'media-description' field didn't contain a port
* @param[in] mediaType The media type to search in
* @return The transport port to which the media stream is sent
*/
uint16_t getMediaPort(const std::string& mediaType) const;
/**
* Adds a 'media-description' field (m=) with all necessary data and attribute fields (a=) with data relevant for this media.<BR>
* After this method is run the following block of fields will be added at the end of the message:
*
* @code
* m=[mediaType] [mediaPort] [mediaProtocol] [mediaFormat]
* a=[1st media attribute]
* a=[2nd media attribute]
* ...
* @endcode
*
* @param[in] mediaType The media type, usually "audio", "video", "text" or "image"
* @param[in] mediaPort The transport port to which the media stream is sent
* @param[in] mediaProtocol The transport protocol, usually "udp", "RTP/AVP" or "RTP/SAVP"
* @param[in] mediaFormat A space-separated list of media format description. For example: "8 96"
* @param[in] mediaAttributes A vector of media attributes. Each string in this vector will be
* translated into a 'media-attribute' field (a=)
* @return True if all fields were added properly or false if at least one field was failed to be added
*/
bool addMediaDescription(const std::string& mediaType, uint16_t mediaPort, const std::string& mediaProtocol, const std::string& mediaFormat, std::vector<std::string> mediaAttributes);
// overridden methods
OsiModelLayer getOsiModelLayer() const { return OsiModelSesionLayer; }
std::string toString() const;
protected:
// implementation of abstract methods
char getHeaderFieldNameValueSeparator() const { return '='; }
bool spacesAllowedBetweenHeaderFieldNameAndValue() const { return false; }
};
}
#endif // PACKETPP_SDP_LAYER