1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18
19 #include "session_info_parser.h"
20 #include "oscl_string_utils.h"
21 #include "rtsp_time_formats.h"
22 #include "sdp_info.h"
23 #include "oscl_str_ptr_len.h"
24 #include "rtsp_range_utils.h"
25 #include "oscl_string_containers.h"
26
27
parseSDPSessionInfo(const char * sdp_text,int length,SDPInfo * sdp)28 SDP_ERROR_CODE parseSDPSessionInfo(const char *sdp_text, int length, SDPInfo *sdp)
29 {
30
31 sessionDescription *session = sdp->getSessionInfo();
32
33 bool o_field_found = false;
34 bool s_field_found = false;
35
36 bool a_control_found = false;
37 bool a_range_found = false;
38 bool t_field_found = false;
39 bool u_field_found = false;
40
41 const char *end = sdp_text + length;
42
43 const char *current_start = sdp_text;
44 const char *line_start_ptr, *line_end_ptr;
45
46 OsclMemoryFragment memFrag;
47
48 // setup the known attribute fields here
49 StrPtrLen author("a=author:");
50 StrPtrLen version("a=version:");
51 StrPtrLen copyright("a=copyright:");
52 StrPtrLen rating("a=rating:");
53 StrPtrLen range("a=range:");
54 StrPtrLen wmf_version("a=X-wmfversion:");
55 StrPtrLen allowrecord("a=X-allowrecord");
56 StrPtrLen random_access("a=random_access_denied");
57 StrPtrLen control("a=control:");
58 StrPtrLen creation_date("a=creation_date:");
59 StrPtrLen video_only_allowed_true("a=video_only_allowed:true");
60 StrPtrLen video_only_allowed_false("a=video_only_allowed:false");
61
62 StrPtrLen etag("a=etag:");
63 //StrPtrLen security("a=X-security_flag:");
64 StrPtrLen random_filler("a=X-random_filler:");
65 StrPtrLen digital_signature("a=X-digital_signature:");
66 StrPtrLen end_of_clip("a=X-end_of_clip:");
67 StrPtrLen launch_URL("a=X-launch_URL:");
68 StrPtrLen app_specific_string("a=X-app_specific_string:");
69 StrPtrLen pause_denied("a=X-pause_denied");
70
71 StrPtrLen qoe_metrics("a=3GPP-QoE-Metrics:");
72 StrPtrLen sdp_int_key("a=3GPP-Integrity-Key:");
73 StrPtrLen sdp_auth("a=3GPP-SDP-Auth:");
74 StrPtrLen alt_gp("a=alt-group:");
75 StrPtrLen asset_info("a=3GPP-Asset-Information:");
76
77 // added for RM
78
79 StrPtrLen sdpplinversion("a=SdpplinVersion:");
80 StrPtrLen flags("a=Flags:");
81 StrPtrLen isrealdatatype("a=IsRealDataType:");
82 StrPtrLen streamcount("a=StreamCount:");
83 StrPtrLen title("a=Title:");
84 StrPtrLen keywords("a=Keywords:");
85 StrPtrLen abstract("a=Abstract:");
86 StrPtrLen ASMrulebook("a=ASMRuleBook");
87
88
89
90 while (get_next_line(current_start, end,
91 line_start_ptr, line_end_ptr))
92 {
93 // check for line type
94 switch (*line_start_ptr)
95 {
96 case 'v':
97 {
98 uint32 version;
99 if (*(line_start_ptr + 1) != '=')
100 {
101 return SDP_BAD_SESSION_FORMAT;
102 }
103 if (PV_atoi(line_start_ptr + 2, 'd', line_end_ptr - line_start_ptr - 2, version) == false)
104 {
105 return SDP_BAD_SESSION_FORMAT;
106 }
107
108 if (version)
109 return SDP_BAD_SESSION_FORMAT;
110 session->setProtocolVersion(version);
111
112 break;
113 }
114
115 case 'o':
116 {
117 if (*(line_start_ptr + 1) != '=')
118 {
119 return SDP_BAD_SESSION_FORMAT;
120 }
121
122 o_field_found = true;
123 // parse through each field
124 const char *sptr, *eptr;
125 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
126 if (sptr >= line_end_ptr)
127 {
128 return SDP_BAD_SESSION_FORMAT;
129 }
130
131 eptr = skip_to_whitespace(sptr, line_end_ptr);
132 if (eptr <= sptr)
133 {
134 return SDP_BAD_SESSION_FORMAT;
135 }
136
137 // get the username
138 memFrag.ptr = (void*)sptr;
139 memFrag.len = (eptr - sptr);
140 session->setOUsername(memFrag);
141
142 // get the sessionID
143 sptr = skip_whitespace(eptr, line_end_ptr);
144 //o=- -1586996066 -1586996066 IN IP4 172.31.105.21
145 //workaround for server found during IOT. 12/12/06
146 while ((*sptr < '0') || (*sptr > '9'))
147 {
148 sptr++;
149 if (sptr >= line_end_ptr)
150 {
151 return SDP_BAD_SESSION_FORMAT;
152 }
153 }
154
155 eptr = skip_to_whitespace(sptr, line_end_ptr);
156 if (eptr <= sptr)
157 {
158 return SDP_BAD_SESSION_FORMAT;
159 }
160
161 uint64 sessionId64;
162 if (!PV_atoi(sptr, 'd', eptr - sptr, sessionId64)) // session ID should be numeric
163 return SDP_BAD_SESSION_FORMAT;
164
165 uint32 sessionId =
166 Oscl_Int64_Utils::get_uint64_lower32(sessionId64);
167 session->setOSessionID(sessionId);
168
169 // get the version
170 sptr = skip_whitespace(eptr, line_end_ptr);
171 //o=- -1586996066 -1586996066 IN IP4 172.31.105.21
172 //workaround for server found during IOT. 12/12/06
173 while ((*sptr < '0') || (*sptr > '9'))
174 {
175 sptr++;
176 if (sptr >= line_end_ptr)
177 {
178 return SDP_BAD_SESSION_FORMAT;
179 }
180 }
181
182 eptr = skip_to_whitespace(sptr, line_end_ptr);
183 if (eptr <= sptr)
184 {
185 return SDP_BAD_SESSION_FORMAT;
186 }
187
188 uint64 version64;
189 if (!PV_atoi(sptr, 'd', eptr - sptr, version64))
190 return SDP_BAD_SESSION_FORMAT;
191
192 uint32 version =
193 Oscl_Int64_Utils::get_uint64_lower32(version64);
194 session->setOVersion(version);
195
196 // get the network type
197 sptr = skip_whitespace(eptr, line_end_ptr);
198 if (sptr >= line_end_ptr)
199 {
200 return SDP_BAD_SESSION_FORMAT;
201 }
202
203 eptr = skip_to_whitespace(sptr, line_end_ptr);
204 if (eptr <= sptr)
205 {
206 return SDP_BAD_SESSION_FORMAT;
207 }
208 memFrag.ptr = (void*)sptr;
209 memFrag.len = (eptr - sptr);
210 session->setONetworkType(memFrag);
211
212 // get the address type
213 sptr = skip_whitespace(eptr, line_end_ptr);
214 if (sptr >= line_end_ptr)
215 {
216 return SDP_BAD_SESSION_FORMAT;
217 }
218
219 eptr = skip_to_whitespace(sptr, line_end_ptr);
220 if (eptr <= sptr)
221 {
222 return SDP_BAD_SESSION_FORMAT;
223 }
224 memFrag.ptr = (void*)sptr;
225 memFrag.len = (eptr - sptr);
226 session->setOAddressType(memFrag);
227
228
229 // get the orginator address
230 sptr = skip_whitespace(eptr, line_end_ptr);
231 if (sptr >= line_end_ptr)
232 {
233 return SDP_BAD_SESSION_FORMAT;
234 }
235
236 eptr = skip_to_whitespace(sptr, line_end_ptr);
237 if (eptr <= sptr)
238 {
239 return SDP_BAD_SESSION_FORMAT;
240 }
241 memFrag.ptr = (void*)sptr;
242 memFrag.len = (eptr - sptr);
243 session->setOAddress(memFrag);
244
245
246 break;
247 }
248
249 case 's':
250 {
251 // the session Name is a string which can contain whitespace
252
253 if (s_field_found) // only one s field allowed at session level
254 return SDP_BAD_SESSION_FORMAT;
255
256 if (*(line_start_ptr + 1) != '=')
257 {
258 return SDP_BAD_SESSION_FORMAT;
259 }
260
261 s_field_found = true;
262
263 // parse through each field
264 const char *sptr, *eptr;
265
266 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
267 if (sptr >= line_end_ptr)
268 {
269 break;
270 // return SDP_BAD_SESSION_FORMAT;
271 }
272
273 eptr = skip_to_line_term(sptr, line_end_ptr);
274 if (eptr <= sptr)
275 {
276
277 return SDP_BAD_SESSION_FORMAT;
278 }
279
280 // get the session name
281 memFrag.ptr = (void*)sptr;
282 memFrag.len = (eptr - sptr);
283 session->setSessionName(memFrag);
284
285 break;
286 }
287
288 case 'u':
289 {
290 // the session Name is a string which can contain whitespace
291
292 if (u_field_found) // only one s field allowed at session level
293 return SDP_BAD_SESSION_FORMAT;
294
295 if (*(line_start_ptr + 1) != '=')
296 {
297 return SDP_BAD_SESSION_FORMAT;
298 }
299
300 u_field_found = true;
301
302 // parse through each field
303 const char *sptr, *eptr;
304
305 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
306 if (sptr >= line_end_ptr)
307 {
308 break;
309 // return SDP_BAD_SESSION_FORMAT;
310 }
311
312 eptr = skip_to_line_term(sptr, line_end_ptr);
313 if (eptr <= sptr)
314 {
315
316 return SDP_BAD_SESSION_FORMAT;
317 }
318
319 // get the session name
320 memFrag.ptr = (void*)sptr;
321 memFrag.len = (eptr - sptr);
322 session->setSessionURI(memFrag);
323
324 break;
325 }
326
327 case 'i':
328 {
329 // the session info is a string which can contain whitespace
330 if (*(line_start_ptr + 1) != '=')
331 {
332 return SDP_BAD_SESSION_FORMAT;
333 }
334
335 // parse through each field
336 const char *sptr, *eptr;
337
338 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
339 if (sptr >= line_end_ptr)
340 {
341 break;
342 // return SDP_BAD_SESSION_FORMAT;
343 }
344
345 eptr = skip_to_line_term(sptr, line_end_ptr);
346 if (eptr <= sptr)
347 {
348 return SDP_BAD_SESSION_FORMAT;
349 }
350
351 // get the session name
352 memFrag.ptr = (void*)sptr;
353 memFrag.len = (eptr - sptr);
354 session->setSessionInformation(memFrag);
355
356
357 break;
358 }
359
360 case 'c':
361 {
362 if (*(line_start_ptr + 1) != '=')
363 {
364 return SDP_BAD_SESSION_FORMAT;
365 }
366
367 session->setCFieldStatus(true);
368 // parse through each field
369 const char *sptr, *eptr;
370
371 // get the connection network type
372 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
373 if (sptr >= line_end_ptr)
374 {
375 return SDP_BAD_SESSION_FORMAT;
376 }
377
378 eptr = skip_to_whitespace(sptr, line_end_ptr);
379 if (eptr <= sptr)
380 {
381 return SDP_BAD_SESSION_FORMAT;
382 }
383
384 memFrag.ptr = (void*)sptr;
385 memFrag.len = (eptr - sptr);
386 session->setCNetworkType(memFrag);
387
388
389 // get the address type
390 sptr = skip_whitespace(eptr, line_end_ptr);
391 if (sptr >= line_end_ptr)
392 {
393 return SDP_BAD_SESSION_FORMAT;
394 }
395
396 eptr = skip_to_whitespace(sptr, line_end_ptr);
397 if (eptr <= sptr)
398 {
399 return SDP_BAD_SESSION_FORMAT;
400 }
401 memFrag.ptr = (void*)sptr;
402 memFrag.len = (eptr - sptr);
403 session->setCAddressType(memFrag);
404 uint32 len = OSCL_MIN((uint32)(eptr - sptr), oscl_strlen("IP6"));
405 if (oscl_strncmp(sptr, "IP6", len) == 0)
406 {
407 //TBD
408 break;
409 }
410
411
412 // get the address
413 sptr = skip_whitespace(eptr, line_end_ptr);
414 if (sptr >= line_end_ptr)
415 {
416 return SDP_BAD_SESSION_FORMAT;
417 }
418
419 eptr = skip_to_whitespace(sptr, line_end_ptr);
420 if (eptr < sptr)
421 {
422 return SDP_BAD_SESSION_FORMAT;
423 }
424 memFrag.ptr = (void*)sptr;
425 memFrag.len = (eptr - sptr);
426 session->setCAddress(memFrag);
427 uint32 address;
428 const char *addrend = sptr;
429 for (; *addrend != '.'; ++addrend);
430
431 PV_atoi(sptr, 'd', addrend - sptr, address);
432
433 if (address >= 224 && address <= 239) //multicast address look for TTL
434 {
435 for (; (*sptr != '/') && (sptr < eptr); ++sptr);
436 if (sptr == eptr)
437 return SDP_BAD_SESSION_FORMAT; // no TTL found in multicast address.
438 else
439 {
440 uint32 ttl;
441 sptr = sptr + 1;
442 if (!PV_atoi(sptr, 'd', eptr - sptr, ttl))
443 return SDP_BAD_SESSION_FORMAT;
444 if (!(ttl <= 255))
445 return SDP_BAD_SESSION_FORMAT; // ttl out of range.
446
447 }
448 }
449 else // unicast address
450 {
451 for (; (*sptr != '/') && (sptr < eptr); ++sptr);
452 if (!oscl_strncmp(sptr, "/", 1))
453 return SDP_BAD_SESSION_FORMAT; //unicast address can not have TTL.
454 }
455
456 if (eptr < line_end_ptr)
457 return SDP_BAD_SESSION_FORMAT;
458 break;
459 }
460
461 case 't':
462 {
463 uint64 start_time, stop_time;
464 if (*(line_start_ptr + 1) != '=')
465 {
466 return SDP_BAD_SESSION_FORMAT;
467 }
468
469 t_field_found = true;
470
471 const char *sptr, *eptr;
472 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
473 if (sptr >= line_end_ptr)
474 {
475 return SDP_BAD_SESSION_FORMAT;
476 }
477
478 eptr = skip_to_whitespace(sptr, line_end_ptr);
479 if (eptr <= sptr)
480 {
481 return SDP_BAD_SESSION_FORMAT;
482 }
483
484 if (PV_atoi(sptr, 'd', (eptr - sptr), start_time) == false)
485 {
486 return SDP_BAD_SESSION_FORMAT;
487 }
488
489 session->setSessionStartTime(start_time);
490
491 sptr = skip_whitespace(eptr, line_end_ptr);
492 if (sptr >= line_end_ptr)
493 {
494 return SDP_BAD_SESSION_FORMAT;
495 }
496
497 eptr = skip_to_whitespace(sptr, line_end_ptr);
498 if (eptr <= sptr)
499 {
500 return SDP_BAD_SESSION_FORMAT;
501 }
502
503 if (PV_atoi(sptr, 'd', (eptr - sptr), stop_time) == false)
504 {
505 return SDP_BAD_SESSION_FORMAT;
506 }
507
508 session->setSessionStopTime(stop_time);
509
510
511 memFrag.ptr = (void*)sptr;
512 memFrag.len = (eptr - sptr);
513 session->setExpiryDate(memFrag);
514 break;
515 }
516
517 case 'r':
518 {
519 uint32 repeat_interval, active_duration;
520 char convert_to_sec = NULL_TERM_CHAR;
521
522 if (*(line_start_ptr + 1) != '=')
523 {
524 return SDP_BAD_SESSION_FORMAT;
525 }
526
527 const char *sptr, *eptr;
528 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
529 if (sptr >= line_end_ptr)
530 {
531 return SDP_BAD_SESSION_FORMAT;
532 }
533
534 eptr = skip_to_whitespace(sptr, line_end_ptr);
535 if (eptr <= sptr)
536 {
537 return SDP_BAD_SESSION_FORMAT;
538 }
539
540 int size = 0;
541 if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
542 {
543 convert_to_sec = *(eptr - 1);
544 size = eptr - 1 - sptr;
545 }
546 else
547 size = eptr - sptr;
548
549
550 if (PV_atoi(sptr, 'd', size, repeat_interval) == false)
551 {
552 return SDP_BAD_SESSION_FORMAT;
553 }
554
555 if (convert_to_sec == 'd')
556 {
557 repeat_interval = repeat_interval * 24 * 3600;
558 convert_to_sec = NULL_TERM_CHAR;
559 }
560 else if (convert_to_sec == 'h')
561 {
562 repeat_interval = repeat_interval * 3600;
563 convert_to_sec = NULL_TERM_CHAR;
564 }
565 else if (convert_to_sec == 'm')
566 {
567 repeat_interval = repeat_interval * 60;
568 convert_to_sec = NULL_TERM_CHAR;
569 }
570 else if (convert_to_sec == 's')
571 {
572 convert_to_sec = NULL_TERM_CHAR; // already in seconds.
573 }
574
575
576
577 session->setRepeatInterval(repeat_interval);
578 eptr = skip_whitespace(eptr, line_end_ptr);
579
580 sptr = skip_whitespace(eptr, line_end_ptr);
581 if (sptr >= line_end_ptr)
582 {
583 return SDP_BAD_SESSION_FORMAT;
584 }
585
586 eptr = skip_to_whitespace(sptr, line_end_ptr);
587 if (eptr <= sptr)
588 {
589 return SDP_BAD_SESSION_FORMAT;
590 }
591
592 if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
593 {
594 convert_to_sec = *(eptr - 1);
595 size = eptr - 1 - sptr;
596 }
597 else
598 size = eptr - sptr;
599
600 if (PV_atoi(sptr, 'd', size, active_duration) == false)
601 {
602 return SDP_BAD_SESSION_FORMAT;
603 }
604
605 if (convert_to_sec == 'd')
606 {
607 active_duration = active_duration * 24 * 3600;
608 convert_to_sec = NULL_TERM_CHAR;
609 }
610 else if (convert_to_sec == 'h')
611 {
612 active_duration = active_duration * 3600;
613 convert_to_sec = NULL_TERM_CHAR;
614 }
615 else if (convert_to_sec == 'm')
616 {
617 active_duration = active_duration * 60;
618 convert_to_sec = NULL_TERM_CHAR;
619 }
620 else if (convert_to_sec == 's')
621 {
622 convert_to_sec = NULL_TERM_CHAR;
623 }
624
625 session->setActiveDuration(active_duration);
626
627 while (sptr < line_end_ptr)
628 {
629 uint32 offset;
630
631 sptr = skip_whitespace(eptr, line_end_ptr);
632 if (sptr >= line_end_ptr)
633 {
634 return SDP_BAD_SESSION_FORMAT;
635 }
636
637 eptr = skip_to_whitespace(sptr, line_end_ptr);
638 if (eptr <= sptr)
639 {
640 return SDP_BAD_SESSION_FORMAT;
641 }
642
643 if (!oscl_strncmp((eptr - 1), "d", 1) || !oscl_strncmp((eptr - 1), "h", 1) || !oscl_strncmp((eptr - 1), "m", 1) || !oscl_strncmp((eptr - 1), "s", 1))
644 {
645 size = eptr - 1 - sptr;
646 convert_to_sec = *(eptr - 1);
647 }
648 else
649 size = eptr - sptr;
650
651 if (PV_atoi(sptr, 'd', size, offset) == false)
652 {
653 return SDP_BAD_SESSION_FORMAT;
654 }
655
656 if (convert_to_sec == 'd')
657 {
658 offset = offset * 24 * 3600;
659 convert_to_sec = NULL_TERM_CHAR;
660 }
661 else if (convert_to_sec == 'h')
662 {
663 offset = offset * 3600;
664 convert_to_sec = NULL_TERM_CHAR;
665 }
666 else if (convert_to_sec == 'm')
667 {
668 offset = offset * 60;
669 convert_to_sec = NULL_TERM_CHAR;
670 }
671 else if (convert_to_sec == 's')
672 {
673 convert_to_sec = NULL_TERM_CHAR;
674 }
675
676 session->addOffset(offset);
677
678 sptr = eptr;
679 }
680 break;
681 }
682
683 case 'b':
684 {
685 if (!oscl_strncmp(line_start_ptr, "b=AS:", oscl_strlen("b=AS:")))
686 {
687 const char *sptr;
688 sptr = line_start_ptr + oscl_strlen("b=AS:");
689 sptr = skip_whitespace(sptr, line_end_ptr);
690 if (sptr >= line_end_ptr)
691 {
692 return SDP_BAD_SESSION_FORMAT;
693 }
694
695 uint32 bitRate;
696 if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bitRate) == true)
697 {
698 session->setBitrate(1000*bitRate);
699 }
700 else
701 {
702 return SDP_BAD_SESSION_FORMAT;
703 }
704 }
705 else if (!oscl_strncmp(line_start_ptr, "b=RS:", oscl_strlen("b=RS:")))
706 {
707 const char *sptr;
708 sptr = line_start_ptr + oscl_strlen("b=AS:");
709 sptr = skip_whitespace(sptr, line_end_ptr);
710 if (sptr >= line_end_ptr)
711 {
712 return SDP_BAD_SESSION_FORMAT;
713 }
714
715 uint32 rtcpBWSender;
716 if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWSender) == true)
717 {
718 session->setRTCPSenderBitRate(rtcpBWSender);
719 }
720 else
721 {
722 return SDP_BAD_SESSION_FORMAT;
723 }
724 }
725 else if (!oscl_strncmp(line_start_ptr, "b=RR:", oscl_strlen("b=RR:")))
726 {
727 const char *sptr;
728 sptr = line_start_ptr + oscl_strlen("b=AS:");
729 sptr = skip_whitespace(sptr, line_end_ptr);
730 if (sptr >= line_end_ptr)
731 {
732 return SDP_BAD_SESSION_FORMAT;
733 }
734
735 uint32 rtcpBWReceiver;
736 if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), rtcpBWReceiver) == true)
737 {
738 session->setRTCPReceiverBitRate(rtcpBWReceiver);
739 }
740 else
741 {
742 return SDP_BAD_SESSION_FORMAT;
743 }
744 }
745 else if (!oscl_strncmp(line_start_ptr, "b=TIAS:", oscl_strlen("b=TIAS:")))
746 {
747 const char *sptr;
748 sptr = line_start_ptr + oscl_strlen("b=TIAS:");
749 sptr = skip_whitespace(sptr, line_end_ptr);
750 if (sptr >= line_end_ptr)
751 {
752 return SDP_BAD_SESSION_FORMAT;
753 }
754
755 uint32 bMod;
756 if (PV_atoi(sptr, 'd', (line_end_ptr - sptr), bMod) == true)
757 {
758 session->setBWtias(1000 * bMod);
759 }
760 else
761 {
762 return SDP_BAD_SESSION_FORMAT;
763 }
764 }
765 break;
766 }
767
768 case 'k':
769 {
770 const char *sptr, *eptr;
771 if (!oscl_strncmp(line_start_ptr, "k=clear:", oscl_strlen("k=clear:")))
772 {
773 sptr = line_start_ptr + oscl_strlen("k=clear:");
774 sptr = skip_whitespace(sptr, line_end_ptr);
775 if (sptr >= line_end_ptr)
776 {
777 return SDP_BAD_SESSION_FORMAT;
778 }
779
780 eptr = skip_to_line_term(sptr, line_end_ptr);
781 if (eptr <= sptr)
782 {
783 return SDP_BAD_SESSION_FORMAT;
784 }
785
786 memFrag.ptr = (void*)sptr;
787 memFrag.len = (eptr - sptr);
788 session->setEncryptionKey(memFrag);
789 }
790 else if (!oscl_strncmp(line_start_ptr, "k=base64:", oscl_strlen("k=base64:")))
791 {
792
793 sptr = line_start_ptr + oscl_strlen("k=base64:");
794 sptr = skip_whitespace(sptr, line_end_ptr);
795 if (sptr >= line_end_ptr)
796 {
797 return SDP_BAD_SESSION_FORMAT;
798 }
799
800 eptr = skip_to_line_term(sptr, line_end_ptr);
801 if (eptr <= sptr)
802 {
803 return SDP_BAD_SESSION_FORMAT;
804 }
805
806 memFrag.ptr = (void*)sptr;
807 memFrag.len = (eptr - sptr);
808 session->setEncryptionKey(memFrag);
809 }
810 else if (!oscl_strncmp(line_start_ptr, "k=uri:", oscl_strlen("k=uri:")))
811 {
812
813 sptr = line_start_ptr + oscl_strlen("k=uri:");
814 sptr = skip_whitespace(sptr, line_end_ptr);
815 if (sptr >= line_end_ptr)
816 {
817 return SDP_BAD_SESSION_FORMAT;
818 }
819
820 eptr = skip_to_line_term(sptr, line_end_ptr);
821 if (eptr <= sptr)
822 {
823 return SDP_BAD_SESSION_FORMAT;
824 }
825
826 memFrag.ptr = (void*)sptr;
827 memFrag.len = (eptr - sptr);
828 session->setEncryptionKey(memFrag);
829 }
830 else
831 {
832 sptr = line_start_ptr;
833 eptr = skip_to_line_term(sptr, line_end_ptr);
834 if (eptr <= sptr)
835 {
836 return SDP_BAD_SESSION_FORMAT;
837 }
838 }
839 break;
840 }
841
842 case 'a':
843 {
844
845 // check to see if it is a known attribute -- otherwise ignore it.
846 const char *sptr, *eptr;
847 if (!oscl_strncmp(line_start_ptr, author.c_str(), author.length()))
848 {
849 sptr = skip_whitespace(line_start_ptr + author.length(),
850 line_end_ptr);
851 if (sptr >= line_end_ptr)
852 {
853 break;
854 // return SDP_BAD_SESSION_FORMAT;
855 }
856
857 eptr = skip_to_line_term(sptr, line_end_ptr);
858 if (eptr <= sptr)
859 {
860 return SDP_BAD_SESSION_FORMAT;
861 }
862
863 memFrag.ptr = (void*)sptr;
864 memFrag.len = (eptr - sptr);
865 session->setAuthor(memFrag);
866
867 }
868 else if (!oscl_strncmp(line_start_ptr, version.c_str(),
869 version.length()))
870 {
871 sptr = skip_whitespace(line_start_ptr + version.length(),
872 line_end_ptr);
873 if (sptr >= line_end_ptr)
874 {
875 break;
876 // return SDP_BAD_SESSION_FORMAT;
877 }
878
879 eptr = skip_to_line_term(sptr, line_end_ptr);
880 if (eptr <= sptr)
881 {
882 return SDP_BAD_SESSION_FORMAT;
883 }
884
885 memFrag.ptr = (void*)sptr;
886 memFrag.len = (eptr - sptr);
887 session->setVersion(memFrag);
888
889
890 }
891 else if (!oscl_strncmp(line_start_ptr, copyright.c_str(),
892 copyright.length()))
893 {
894
895 sptr = skip_whitespace(line_start_ptr + copyright.length(),
896 line_end_ptr);
897 if (sptr >= line_end_ptr)
898 {
899 break;
900 // return SDP_BAD_SESSION_FORMAT;
901 }
902
903 eptr = skip_to_line_term(sptr, line_end_ptr);
904 if (eptr <= sptr)
905 {
906 return SDP_BAD_SESSION_FORMAT;
907 }
908
909 memFrag.ptr = (void*)sptr;
910 memFrag.len = (eptr - sptr);
911 session->setCopyright(memFrag);
912
913 }
914 else if (!oscl_strncmp(line_start_ptr, rating.c_str(), rating.length()))
915 {
916
917 sptr = skip_whitespace(line_start_ptr + rating.length(),
918 line_end_ptr);
919 if (sptr >= line_end_ptr)
920 {
921 break;
922 // return SDP_BAD_SESSION_FORMAT;
923 }
924
925 eptr = skip_to_line_term(sptr, line_end_ptr);
926 if (eptr <= sptr)
927 {
928 return SDP_BAD_SESSION_FORMAT;
929 }
930 memFrag.ptr = (void*)sptr;
931 memFrag.len = (eptr - sptr);
932 session->setRating(memFrag);
933 }
934 else if (!oscl_strncmp(line_start_ptr, range.c_str(), range.length()))
935 {
936 RtspRangeType rangeVal;
937 if (parseRtspRange((line_start_ptr + range.length()), (line_end_ptr - line_start_ptr - range.length()),
938 rangeVal))
939 {
940 session->setRange(rangeVal);
941 a_range_found = true;
942 }
943 }
944 else if (!oscl_strncmp(line_start_ptr, wmf_version.c_str(),
945 wmf_version.length()))
946 {
947
948 sptr = skip_whitespace(line_start_ptr + wmf_version.length(),
949 line_end_ptr);
950 if (sptr >= line_end_ptr)
951 {
952 break;
953 // return SDP_BAD_SESSION_FORMAT;
954 }
955
956 eptr = skip_to_line_term(sptr, line_end_ptr);
957 if (eptr <= sptr)
958 {
959 return SDP_BAD_SESSION_FORMAT;
960 }
961
962 memFrag.ptr = (void*)sptr;
963 memFrag.len = (eptr - sptr);
964 session->setWmfVersion(memFrag);
965 }
966 else if (!oscl_strncmp(line_start_ptr, allowrecord.c_str(),
967 allowrecord.length()))
968 {
969 session->setAllowRecord(true);
970 }
971 else if (!oscl_strncmp(line_start_ptr, random_access.c_str(),
972 random_access.length()))
973 {
974 session->setRandomAccessDenied(true);
975 }
976
977 else if (!oscl_strncmp(line_start_ptr, control.c_str(),
978 control.length()))
979 {
980
981 sptr = skip_whitespace(line_start_ptr + control.length(),
982 line_end_ptr);
983 if (sptr >= line_end_ptr)
984 {
985 break;
986 // return SDP_BAD_SESSION_FORMAT;
987 }
988
989 eptr = skip_to_line_term(sptr, line_end_ptr);
990 if (eptr <= sptr)
991 {
992 return SDP_BAD_SESSION_FORMAT;
993 }
994
995 OSCL_HeapString<SDPParserAlloc> control_str(sptr, eptr - sptr);
996 session->setControlURL(control_str);
997 a_control_found = true;
998
999 }
1000
1001 else if (!oscl_strncmp(line_start_ptr, creation_date.c_str(),
1002 creation_date.length()))
1003 {
1004
1005 sptr = skip_whitespace(line_start_ptr + creation_date.length(),
1006 line_end_ptr);
1007 if (sptr >= line_end_ptr)
1008 {
1009
1010 return SDP_BAD_SESSION_FORMAT;
1011 }
1012
1013 eptr = skip_to_line_term(sptr, line_end_ptr);
1014 if (eptr <= sptr)
1015 {
1016 return SDP_BAD_SESSION_FORMAT;
1017 }
1018
1019 memFrag.ptr = (void*)sptr;
1020 memFrag.len = (eptr - sptr);
1021 session->setCreationDate(memFrag);
1022 }
1023
1024 else if (!oscl_strncmp(line_start_ptr, video_only_allowed_true.c_str(),
1025 video_only_allowed_true.length()))
1026 {
1027
1028 session->setVideoOnlyAllowed(ALLOWED);
1029 }
1030
1031 else if (!oscl_strncmp(line_start_ptr, video_only_allowed_false.c_str(),
1032 video_only_allowed_false.length()))
1033 {
1034 session->setVideoOnlyAllowed(NOT_ALLOWED);
1035 }
1036
1037 else if (!oscl_strncmp(line_start_ptr, etag.c_str(), etag.length()))
1038 {
1039
1040 sptr = skip_whitespace(line_start_ptr + etag.length(),
1041 line_end_ptr);
1042 if (sptr >= line_end_ptr)
1043 {
1044 break;
1045 }
1046
1047 eptr = skip_to_line_term(sptr, line_end_ptr);
1048 if (eptr <= sptr)
1049 {
1050 return SDP_BAD_SESSION_FORMAT;
1051 }
1052
1053 memFrag.ptr = (void*)sptr;
1054 memFrag.len = (eptr - sptr);
1055 session->setETag(memFrag);
1056 }
1057
1058 else if (!oscl_strncmp(line_start_ptr, random_filler.c_str(), random_filler.length()))
1059 {
1060
1061 sptr = skip_whitespace(line_start_ptr + random_filler.length(), line_end_ptr);
1062
1063 if (sptr >= line_end_ptr)
1064 {
1065 break;
1066 }
1067
1068 eptr = skip_to_line_term(sptr, line_end_ptr);
1069 if (eptr <= sptr)
1070 {
1071 return SDP_BAD_SESSION_FORMAT;
1072 }
1073
1074 memFrag.ptr = (void*)sptr;
1075 memFrag.len = (eptr - sptr);
1076 session->setRandomFiller(memFrag);
1077 }
1078
1079 else if (!oscl_strncmp(line_start_ptr, digital_signature.c_str(),
1080 digital_signature.length()))
1081 {
1082
1083 sptr = skip_whitespace(line_start_ptr + digital_signature.length(), line_end_ptr);
1084
1085 if (sptr >= line_end_ptr)
1086 {
1087 break;
1088 }
1089
1090 eptr = skip_to_line_term(sptr, line_end_ptr);
1091 if (eptr <= sptr)
1092 {
1093 return SDP_BAD_SESSION_FORMAT;
1094 }
1095
1096 memFrag.ptr = (void*)sptr;
1097 memFrag.len = (eptr - sptr);
1098 session->setDigitalSignature(memFrag);
1099 }
1100
1101 else if (!oscl_strncmp(line_start_ptr, launch_URL.c_str(), launch_URL.length()))
1102 {
1103
1104 sptr = skip_whitespace(line_start_ptr + launch_URL.length(), line_end_ptr);
1105
1106 if (sptr >= line_end_ptr)
1107 {
1108 break;
1109 }
1110
1111 eptr = skip_to_line_term(sptr, line_end_ptr);
1112 if (eptr <= sptr)
1113 {
1114 return SDP_BAD_SESSION_FORMAT;
1115 }
1116
1117 memFrag.ptr = (void*)sptr;
1118 memFrag.len = (eptr - sptr);
1119 session->setLaunchURL(memFrag);
1120 }
1121
1122 else if (!oscl_strncmp(line_start_ptr, end_of_clip.c_str(), end_of_clip.length()))
1123 {
1124
1125 sptr = skip_whitespace(line_start_ptr + end_of_clip.length(),
1126 line_end_ptr);
1127
1128 if (sptr >= line_end_ptr)
1129 {
1130 break;
1131 }
1132
1133 eptr = skip_to_line_term(sptr, line_end_ptr);
1134 if (eptr <= sptr)
1135 {
1136 return SDP_BAD_SESSION_FORMAT;
1137 }
1138 //uint32 action = 0;
1139 StrPtrLen nothing("NOTHING");
1140 StrPtrLen close("CLOSE");
1141 StrPtrLen launch("LAUNCH");
1142
1143 if (!oscl_strncmp(nothing.c_str(), sptr, nothing.length()))
1144 {
1145 session->setEndOfClipAction(DEFAULT);
1146 }
1147 else if (!oscl_strncmp(close.c_str(), sptr, close.length()))
1148 {
1149 session->setEndOfClipAction(CLOSE_PLAYER);
1150 }
1151 else if (!oscl_strncmp(launch.c_str(), sptr, launch.length()))
1152 {
1153 session->setEndOfClipAction(LAUNCH_URL);
1154 }
1155 }
1156
1157 // added for RM
1158 else if (!oscl_strncmp(line_start_ptr, sdpplinversion.c_str(),
1159 sdpplinversion.length()))
1160 {
1161 uint32 version;
1162
1163 sptr = skip_whitespace(line_start_ptr + sdpplinversion.length(), line_end_ptr);
1164 if (sptr >= line_end_ptr)
1165 {
1166 return SDP_BAD_SESSION_FORMAT;
1167 }
1168
1169 eptr = skip_to_whitespace(sptr, line_end_ptr);
1170 if (eptr <= sptr)
1171 {
1172 return SDP_BAD_SESSION_FORMAT;
1173 }
1174
1175 if (PV_atoi(sptr, 'd', (eptr - sptr), version) == false)
1176 {
1177 return SDP_BAD_SESSION_FORMAT;
1178 }
1179
1180 session->setSdpplinVersion(version);
1181
1182 }
1183
1184 else if (!oscl_strncmp(line_start_ptr, flags.c_str(),
1185 flags.length()))
1186 {
1187 uint32 flag;
1188 sptr = skip_whitespace(line_start_ptr + flags.length(), line_end_ptr);
1189 if (sptr >= line_end_ptr)
1190 {
1191 return SDP_BAD_SESSION_FORMAT;
1192 }
1193
1194 eptr = skip_to_whitespace(sptr, line_end_ptr);
1195 if (eptr <= sptr)
1196 {
1197 return SDP_BAD_SESSION_FORMAT;
1198 }
1199
1200 for (; *sptr != ';'; sptr++);
1201 sptr = sptr + 1;
1202
1203 if (PV_atoi(sptr, 'd', (eptr - sptr), flag) == false)
1204 {
1205 return SDP_BAD_SESSION_FORMAT;
1206 }
1207
1208 session->setFlags(flag);
1209
1210 }
1211
1212 else if (!oscl_strncmp(line_start_ptr, streamcount.c_str(),
1213 streamcount.length()))
1214 {
1215 uint32 count;
1216
1217 sptr = skip_whitespace(line_start_ptr + streamcount.length(), line_end_ptr);
1218 if (sptr >= line_end_ptr)
1219 {
1220 return SDP_BAD_SESSION_FORMAT;
1221 }
1222
1223 eptr = skip_to_whitespace(sptr, line_end_ptr);
1224 if (eptr <= sptr)
1225 {
1226 return SDP_BAD_SESSION_FORMAT;
1227 }
1228
1229 for (; *sptr != ';'; sptr++);
1230 sptr = sptr + 1;
1231
1232 if (PV_atoi(sptr, 'd', (eptr - sptr), count) == false)
1233 {
1234 return SDP_BAD_SESSION_FORMAT;
1235 }
1236
1237 session->setStreamCount(count);
1238
1239 }
1240
1241 else if (!oscl_strncmp(line_start_ptr, isrealdatatype.c_str(),
1242 isrealdatatype.length()))
1243 {
1244 uint32 isrealdata;
1245
1246 sptr = skip_whitespace(line_start_ptr + isrealdatatype.length(), line_end_ptr);
1247 if (sptr >= line_end_ptr)
1248 {
1249 return SDP_BAD_SESSION_FORMAT;
1250 }
1251
1252 eptr = skip_to_whitespace(sptr, line_end_ptr);
1253 if (eptr <= sptr)
1254 {
1255 return SDP_BAD_SESSION_FORMAT;
1256 }
1257
1258 for (; *sptr != ';'; sptr++);
1259 sptr = sptr + 1;
1260
1261 if (PV_atoi(sptr, 'd', (eptr - sptr), isrealdata) == false)
1262 {
1263 return SDP_BAD_SESSION_FORMAT;
1264 }
1265
1266 session->setIsRealDataType(isrealdata);
1267 }
1268 else if (!oscl_strncmp(line_start_ptr, "a=Author:", author.length()))
1269 {
1270 sptr = skip_whitespace(line_start_ptr + author.length(),
1271 line_end_ptr);
1272 if (sptr >= line_end_ptr)
1273 {
1274 break;
1275 // return SDP_BAD_SESSION_FORMAT;
1276 }
1277
1278 eptr = skip_to_line_term(sptr, line_end_ptr);
1279 if (eptr <= sptr)
1280 {
1281 return SDP_BAD_SESSION_FORMAT;
1282 }
1283
1284 for (; *sptr != ';'; sptr++);
1285 sptr = sptr + 1;
1286
1287 memFrag.ptr = (void*)sptr;
1288 memFrag.len = (eptr - sptr);
1289 session->setAuthor(memFrag);
1290
1291 }
1292 else if (!oscl_strncmp(line_start_ptr, "a=Copyright:", copyright.length()))
1293 {
1294 sptr = skip_whitespace(line_start_ptr + copyright.length(),
1295 line_end_ptr);
1296 if (sptr >= line_end_ptr)
1297 {
1298 break;
1299 // return SDP_BAD_SESSION_FORMAT;
1300 }
1301
1302 eptr = skip_to_line_term(sptr, line_end_ptr);
1303 if (eptr <= sptr)
1304 {
1305 return SDP_BAD_SESSION_FORMAT;
1306 }
1307
1308 for (; *sptr != ';'; sptr++);
1309 sptr = sptr + 1;
1310
1311 memFrag.ptr = (void*)sptr;
1312 memFrag.len = (eptr - sptr);
1313 session->setCopyright(memFrag);
1314
1315 }
1316 else if (!oscl_strncmp(line_start_ptr, title.c_str(),
1317 title.length()))
1318 {
1319
1320 sptr = skip_whitespace(line_start_ptr + title.length(),
1321 line_end_ptr);
1322 if (sptr >= line_end_ptr)
1323 {
1324 break;
1325 // return SDP_BAD_SESSION_FORMAT;
1326 }
1327
1328 eptr = skip_to_line_term(sptr, line_end_ptr);
1329 if (eptr <= sptr)
1330 {
1331 return SDP_BAD_SESSION_FORMAT;
1332 }
1333
1334 for (; *sptr != ';'; sptr++);
1335 sptr = sptr + 1;
1336
1337 memFrag.ptr = (void*)(sptr + 1);
1338 memFrag.len = ((eptr - 2) - sptr);
1339 session->setTitle(memFrag);
1340
1341 }
1342
1343 else if (!oscl_strncmp(line_start_ptr, keywords.c_str(),
1344 keywords.length()))
1345 {
1346
1347 sptr = skip_whitespace(line_start_ptr + keywords.length(),
1348 line_end_ptr);
1349 if (sptr >= line_end_ptr)
1350 {
1351 break;
1352 // return SDP_BAD_SESSION_FORMAT;
1353 }
1354
1355 eptr = skip_to_line_term(sptr, line_end_ptr);
1356 if (eptr <= sptr)
1357 {
1358 return SDP_BAD_SESSION_FORMAT;
1359 }
1360
1361 for (; *sptr != ';'; sptr++);
1362 sptr = sptr + 1;
1363
1364 memFrag.ptr = (void*)(sptr + 1);
1365 memFrag.len = ((eptr - 2) - sptr);
1366 session->setKeywords(memFrag);
1367
1368 }
1369
1370 else if (!oscl_strncmp(line_start_ptr, abstract.c_str(),
1371 abstract.length()))
1372 {
1373
1374 sptr = skip_whitespace(line_start_ptr + abstract.length(),
1375 line_end_ptr);
1376 if (sptr >= line_end_ptr)
1377 {
1378 break;
1379 // return SDP_BAD_SESSION_FORMAT;
1380 }
1381
1382 eptr = skip_to_line_term(sptr, line_end_ptr);
1383 if (eptr <= sptr)
1384 {
1385 return SDP_BAD_SESSION_FORMAT;
1386 }
1387
1388 for (; *sptr != ';'; sptr++);
1389 sptr = sptr + 1;
1390
1391 memFrag.ptr = (void*)(sptr + 1);
1392 memFrag.len = ((eptr - 2) - sptr);
1393 session->setAbstract(memFrag);
1394
1395 }
1396
1397 else if (!oscl_strncmp(line_start_ptr, ASMrulebook.c_str(),
1398 ASMrulebook.length()))
1399 {
1400
1401 sptr = skip_whitespace(line_start_ptr + ASMrulebook.length(),
1402 line_end_ptr);
1403 if (sptr >= line_end_ptr)
1404 {
1405 break;
1406 // return SDP_BAD_SESSION_FORMAT;
1407 }
1408
1409 eptr = skip_to_line_term(sptr, line_end_ptr);
1410 if (eptr <= sptr)
1411 {
1412 return SDP_BAD_SESSION_FORMAT;
1413 }
1414
1415 for (; *sptr != ';'; sptr++);
1416 sptr = sptr + 1;
1417
1418 memFrag.ptr = (void*)sptr;
1419 memFrag.len = (eptr - sptr);
1420 session->setASMRuleBook(memFrag);
1421
1422 }
1423 else if (!oscl_strncmp(line_start_ptr, app_specific_string.c_str(), app_specific_string.length()))
1424 {
1425
1426 sptr = skip_whitespace(line_start_ptr + app_specific_string.length(), line_end_ptr);
1427
1428 if (sptr >= line_end_ptr)
1429 {
1430 break;
1431 }
1432
1433 eptr = skip_to_line_term(sptr, line_end_ptr);
1434 if (eptr <= sptr)
1435 {
1436 return SDP_BAD_SESSION_FORMAT;
1437 }
1438
1439 memFrag.ptr = (void*)sptr;
1440 memFrag.len = (eptr - sptr);
1441 session->setAppSpecificString(memFrag);
1442 }
1443
1444 else if (!oscl_strncmp(line_start_ptr, pause_denied.c_str(),
1445 pause_denied.length()))
1446 {
1447 session->setPauseDenied(true);
1448 }
1449 else if (!oscl_strncmp(line_start_ptr, qoe_metrics.c_str(),
1450 qoe_metrics.length()))
1451 {
1452 const char *sptr;
1453 sptr = line_start_ptr + qoe_metrics.length();
1454 QoEMetricsType qMetrics;
1455 oscl_memset(qMetrics.name, 0, 7);
1456 qMetrics.rateFmt = QoEMetricsType::VAL;
1457 qMetrics.rateVal = 0;
1458 qMetrics.paramFmt = QoEMetricsType::IDIGIT;
1459 qMetrics.paramExtIdigit = 0;
1460 if (!parseQoEMetrics(sptr, line_end_ptr, qMetrics))
1461 return SDP_BAD_SESSION_FORMAT;
1462
1463 session->setQoEMetrics(qMetrics);
1464
1465 }
1466 else if (!oscl_strncmp(line_start_ptr, sdp_int_key.c_str(),
1467 sdp_int_key.length()))
1468 {
1469 const char *sptr = line_start_ptr + sdp_int_key.length();
1470 const char *eptr = sptr;
1471 bool found_OMADRMv2_keyMethod = false;
1472
1473
1474 sptr = skip_whitespace(sptr, line_end_ptr);
1475 if (sptr > line_end_ptr)
1476 return SDP_BAD_SESSION_FORMAT;
1477
1478
1479 if (oscl_strncmp(sptr, "OMADRMv2:", oscl_strlen("OMADRMv2:")))
1480 {
1481
1482 for (; *eptr != ':' ; ++eptr);
1483 session->setKeyMethod(sptr, eptr - sptr);
1484
1485 }
1486 else
1487 {
1488 found_OMADRMv2_keyMethod = true;
1489 eptr = sptr + oscl_strlen("OMADRMv2:");
1490 session->setKeyMethod(sptr, eptr - sptr);
1491 }
1492
1493 sptr = eptr ;
1494
1495 sptr = skip_whitespace(sptr, line_end_ptr);
1496
1497 if (sptr > line_end_ptr)
1498 return SDP_BAD_SESSION_FORMAT;
1499 else if (sptr == line_end_ptr)
1500 break;
1501
1502
1503 if (!found_OMADRMv2_keyMethod)
1504 {
1505
1506 session->setKeyData(sptr, line_end_ptr - sptr);
1507 break;
1508 }
1509
1510 eptr = sptr;
1511 for (; *eptr != ','; ++eptr);
1512
1513 session->setKeyData(sptr, (eptr - sptr));
1514
1515 sptr = eptr + 1;
1516
1517 if (sptr > line_end_ptr)
1518 return SDP_BAD_SESSION_FORMAT;
1519
1520 if (oscl_strncmp(sptr, "\"", 1))
1521 return SDP_BAD_SESSION_FORMAT;
1522 else
1523 sptr = sptr + 1;
1524
1525 if (sptr > line_end_ptr)
1526 return SDP_BAD_SESSION_FORMAT;
1527
1528 eptr = sptr;
1529
1530 for (; *eptr != '\"'; ++eptr);
1531
1532 session->setKeyContentIdURI(sptr , (eptr - sptr));
1533
1534 sptr = eptr + 1;
1535
1536 if (sptr > line_end_ptr)
1537 return SDP_BAD_SESSION_FORMAT;
1538 if (oscl_strncmp(sptr, ",", 1))
1539 return SDP_BAD_SESSION_FORMAT;
1540
1541 sptr = sptr + 1;
1542
1543 if (oscl_strncmp(sptr, "\"", 1))
1544 return SDP_BAD_SESSION_FORMAT;
1545 else
1546 sptr = sptr + 1;
1547
1548 if (sptr > line_end_ptr)
1549 return SDP_BAD_SESSION_FORMAT;
1550
1551 eptr = sptr;
1552
1553 for (; *eptr != '"'; ++eptr);
1554
1555 session->setKeyRightIssuerURI(sptr , ((eptr - 1) - sptr));
1556
1557 sptr = eptr + 1;
1558 sptr = skip_whitespace(sptr, line_end_ptr);
1559
1560 if (sptr > line_end_ptr)
1561 return SDP_BAD_SESSION_FORMAT;
1562
1563
1564 session->setKeyFreshToken(sptr, (line_end_ptr - sptr));
1565
1566 }
1567 else if (!oscl_strncmp(line_start_ptr, sdp_auth.c_str(),
1568 sdp_auth.length()))
1569 {
1570 const char *sptr = line_start_ptr + sdp_auth.length();
1571 memFrag.ptr = (void *)sptr;
1572 memFrag.len = line_end_ptr - sptr;
1573
1574 session->setSdpAuthTag(memFrag);
1575 }
1576 else if (!oscl_strncmp(line_start_ptr, asset_info.c_str(),
1577 asset_info.length()))
1578 {
1579 const char *sptr = line_start_ptr + asset_info.length();
1580 AssetInfoType assetInfo;
1581 if (!parseAssetInfo(sptr, line_end_ptr, assetInfo))
1582 return SDP_BAD_SESSION_FORMAT;
1583
1584 session->setAssetInfo(assetInfo);
1585
1586 }
1587 else if (!oscl_strncmp(line_start_ptr, alt_gp.c_str(),
1588 alt_gp.length()))
1589 {
1590 const char *sptr = line_start_ptr + alt_gp.length();
1591 sptr = skip_whitespace(sptr, line_end_ptr);
1592
1593 if (!oscl_strncmp(sptr, "BW", oscl_strlen("BW")))
1594 session->setAltGroupBW(sptr, line_end_ptr - sptr);
1595 else if (!oscl_strncmp(sptr, "LANG", oscl_strlen("LANG")))
1596 session->setAltGroupLANG(sptr, line_end_ptr - sptr);
1597 else
1598 return SDP_BAD_SESSION_FORMAT;
1599
1600 }
1601 if (!oscl_strncmp(line_start_ptr, "a=maxprate:", oscl_strlen("a=maxprate:")))
1602 {
1603 line_start_ptr += oscl_strlen("a=maxprate:");
1604 OsclFloat rate;
1605 if (!PV_atof(line_start_ptr, line_end_ptr - line_start_ptr, rate))
1606 return SDP_BAD_SESSION_FORMAT;
1607 session->setMaxprate(rate);
1608 }
1609
1610 break;
1611 }
1612 case 'e':
1613 {
1614 if (*(line_start_ptr + 1) != '=')
1615 {
1616 return SDP_BAD_SESSION_FORMAT;
1617 }
1618
1619 const char *sptr, *eptr;
1620
1621 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
1622 if (sptr >= line_end_ptr)
1623 {
1624 break;
1625 }
1626
1627 eptr = skip_to_line_term(sptr, line_end_ptr);
1628 if (eptr <= sptr)
1629 {
1630 return SDP_BAD_SESSION_FORMAT;
1631 }
1632
1633 memFrag.ptr = (void*)sptr;
1634 memFrag.len = (eptr - sptr);
1635 session->setEmail(memFrag);
1636 break;
1637 }
1638 case 'p':
1639 {
1640 if (*(line_start_ptr + 1) != '=')
1641 {
1642 return SDP_BAD_SESSION_FORMAT;
1643 }
1644
1645 const char *sptr, *eptr;
1646
1647 sptr = skip_whitespace(line_start_ptr + 2, line_end_ptr);
1648 if (sptr >= line_end_ptr)
1649 {
1650 break;
1651 }
1652
1653 eptr = skip_to_line_term(sptr, line_end_ptr);
1654 if (eptr <= sptr)
1655 {
1656 return SDP_BAD_SESSION_FORMAT;
1657 }
1658
1659 memFrag.ptr = (void*)sptr;
1660 memFrag.len = (eptr - sptr);
1661 session->setPhoneNumber(memFrag);
1662 break;
1663 }
1664 }
1665 current_start = line_end_ptr;
1666 }
1667
1668 return SDP_SUCCESS;
1669 }
1670