realrtsp: fix read after the end of the string if the input buffer length isn't a...
[vlc.git] / modules / access / rtsp / real_sdpplin.c
1 /*
2  * Copyright (C) 2002-2003 the xine project
3  *
4  * This file is part of xine, a free video player.
5  *
6  * xine is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * xine is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
19  *
20  * $Id$
21  *
22  * sdp/sdpplin parser.
23  *
24  */
25  
26 #include "real.h"
27 #define BUFLEN 32000
28
29 /*
30  * Decodes base64 strings (based upon b64 package)
31  */
32
33 static char *b64_decode(const char *in, char *out, int *size) {
34
35   char dtable[256];              /* Encode / decode table */
36   int i,k;
37   unsigned int j;
38
39   for( i = 0; i < 256; i++ )
40     dtable[i] = 0x80;
41
42   for( i = 'A'; i <= 'Z'; i++ )
43     dtable[i] = 0 + (i - 'A');
44
45   for( i = 'a'; i <= 'z'; i++ )
46     dtable[i] = 26 + (i - 'a');
47
48   for( i = '0'; i <= '9'; i++ )
49     dtable[i] = 52 + (i - '0');
50
51   dtable['+'] = 62;
52   dtable['/'] = 63;
53   dtable['='] = 0;
54
55   k=0;
56   /*CONSTANTCONDITION*/
57   int in_len = strlen(in);
58   for (j=0; j < in_len; j+=4) {
59     char a[4], b[4];
60
61     for (i = 0; i < 4 && j + i < in_len; i++) {
62       int c = in[i+j];
63
64       if (dtable[c] & 0x80) {
65         printf("Illegal character '%c' in input.\n", c);
66         exit(1);
67       }
68       a[i] = (char) c;
69       b[i] = (char) dtable[c];
70     }
71     //xine_buffer_ensure_size(out, k+3);
72     out[k++] = (b[0] << 2) | (b[1] >> 4);
73     out[k++] = (b[1] << 4) | (b[2] >> 2);
74     out[k++] = (b[2] << 6) | b[3];
75     i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
76     if (i < 3) {
77       out[k]=0;
78       *size=k;
79       return out;
80     }
81   }
82   out[k]=0;
83   *size=k;
84   return out;
85 }
86
87 static char *nl(char *data) {
88
89   char *nlptr = (data) ? strchr(data,'\n') : NULL;
90   return (nlptr) ? nlptr + 1 : NULL;
91 }
92
93 static int filter(const char *in, const char *filter, char **out, size_t outlen) {
94
95   int flen=strlen(filter);
96   size_t len;
97
98   if (!in) return 0;
99
100   len = (strchr(in,'\n')) ? (size_t)(strchr(in,'\n')-in) : strlen(in);
101   if (!strncmp(in,filter,flen)) {
102     if(in[flen]=='"') flen++;
103     if(in[len-1]==13) len--;
104     if(in[len-1]=='"') len--;
105     if( len-flen+1 > outlen )
106     {
107         printf("Discarding end of string to avoid overflow");
108         len=outlen+flen-1;
109     }
110     memcpy(*out, in+flen, len-flen+1);
111     (*out)[len-flen]=0;
112     return len-flen;
113   }
114   return 0;
115 }
116
117 static sdpplin_stream_t *sdpplin_parse_stream(char **data) {
118
119   sdpplin_stream_t *desc;
120   char* buf = NULL;
121   char* decoded = NULL;
122   int handled;
123
124   desc = calloc( 1, sizeof(sdpplin_stream_t) );
125   if( !desc )
126     return NULL;
127
128   buf = malloc( BUFLEN );
129   if( !buf )
130     goto error;
131
132   decoded = malloc( BUFLEN );
133   if( !decoded )
134     goto error;
135
136   if (filter(*data, "m=", &buf, BUFLEN)) {
137     desc->id = strdup(buf);
138   } else {
139     lprintf("sdpplin: no m= found.\n");
140     goto error;
141   }
142   *data=nl(*data);
143
144   while (*data && **data && *data[0]!='m') {
145     handled=0;
146
147     if(filter(*data,"a=control:streamid=",&buf, BUFLEN)) {
148         /* This way negative values are mapped to unfeasibly high
149          * values, and will be discarded afterward
150          */
151         unsigned long tmp = strtoul(buf, NULL, 10);
152         if ( tmp > UINT16_MAX )
153             lprintf("stream id out of bound: %lu\n", tmp);
154         else
155             desc->stream_id=tmp;
156         handled=1;
157         *data=nl(*data);
158     }
159     if(filter(*data,"a=MaxBitRate:integer;",&buf, BUFLEN)) {
160       desc->max_bit_rate=atoi(buf);
161       if (!desc->avg_bit_rate)
162         desc->avg_bit_rate=desc->max_bit_rate;
163       handled=1;
164       *data=nl(*data);
165     }
166     if(filter(*data,"a=MaxPacketSize:integer;",&buf, BUFLEN)) {
167       desc->max_packet_size=atoi(buf);
168       if (!desc->avg_packet_size)
169         desc->avg_packet_size=desc->max_packet_size;
170       handled=1;
171       *data=nl(*data);
172     }
173     if(filter(*data,"a=StartTime:integer;",&buf, BUFLEN)) {
174       desc->start_time=atoi(buf);
175       handled=1;
176       *data=nl(*data);
177     }
178     if(filter(*data,"a=Preroll:integer;",&buf, BUFLEN)) {
179       desc->preroll=atoi(buf);
180       handled=1;
181       *data=nl(*data);
182     }
183     if(filter(*data,"a=length:npt=",&buf, BUFLEN)) {
184       desc->duration=(uint32_t)(atof(buf)*1000);
185       handled=1;
186       *data=nl(*data);
187     }
188     if(filter(*data,"a=StreamName:string;",&buf, BUFLEN)) {
189       desc->stream_name=strdup(buf);
190       desc->stream_name_size=strlen(desc->stream_name);
191       handled=1;
192       *data=nl(*data);
193     }
194     if(filter(*data,"a=mimetype:string;",&buf, BUFLEN)) {
195       desc->mime_type=strdup(buf);
196       desc->mime_type_size=strlen(desc->mime_type);
197       handled=1;
198       *data=nl(*data);
199     }
200     if(filter(*data,"a=OpaqueData:buffer;",&buf, BUFLEN)) {
201       decoded = b64_decode(buf, decoded, &(desc->mlti_data_size));
202       if ( decoded != NULL ) {
203           desc->mlti_data = malloc(desc->mlti_data_size);
204           memcpy(desc->mlti_data, decoded, desc->mlti_data_size);
205           handled=1;
206           *data=nl(*data);
207           lprintf("mlti_data_size: %i\n", desc->mlti_data_size);
208       }
209     }
210     if(filter(*data,"a=ASMRuleBook:string;",&buf, BUFLEN)) {
211       desc->asm_rule_book=strdup(buf);
212       handled=1;
213       *data=nl(*data);
214     }
215
216     if(!handled) {
217 #ifdef LOG
218       int len=strchr(*data,'\n')-(*data);
219       memcpy(buf, *data, len+1);
220       buf[len]=0;
221       printf("libreal: sdpplin: not handled: '%s'\n", buf);
222 #endif
223       *data=nl(*data);
224     }
225   }
226   free( buf );
227   free( decoded) ;
228   return desc;
229
230 error:
231   free( decoded );
232   free( desc );
233   free( buf );
234   return NULL;
235 }
236
237
238 sdpplin_t *sdpplin_parse(char *data)
239 {
240   sdpplin_t*        desc;
241   sdpplin_stream_t* stream;
242   char*             buf;
243   char*             decoded;
244   int               handled;
245   int               len;
246
247   desc = calloc( 1, sizeof(sdpplin_t) );
248   if( !desc )
249     return NULL;
250
251   buf = malloc( BUFLEN );
252   if( !buf )
253   {
254     free( desc );
255     return NULL;
256   }
257
258   decoded = malloc( BUFLEN );
259   if( !decoded )
260   {
261     free( buf );
262     free( desc );
263     return NULL;
264   }
265   desc->stream = NULL;
266
267   while (data && *data) {
268     handled=0;
269
270     if (filter(data, "m=", &buf, BUFLEN)) {
271         if ( !desc->stream ) {
272             fprintf(stderr, "sdpplin.c: stream identifier found before stream count, skipping.");
273             continue;
274         }
275         stream=sdpplin_parse_stream(&data);
276         lprintf("got data for stream id %u\n", stream->stream_id);
277         if ( stream->stream_id >= desc->stream_count )
278             lprintf("stream id %u is greater than stream count %u\n", stream->stream_id, desc->stream_count);
279         else
280             desc->stream[stream->stream_id]=stream;
281         continue;
282     }
283     if(filter(data,"a=Title:buffer;",&buf, BUFLEN)) {
284       decoded=b64_decode(buf, decoded, &len);
285           if ( decoded != NULL ) {
286           desc->title=strdup(decoded);
287           handled=1;
288           data=nl(data);
289       }
290     }
291     if(filter(data,"a=Author:buffer;",&buf, BUFLEN)) {
292       decoded=b64_decode(buf, decoded, &len);
293           if ( decoded != NULL ) {
294           desc->author=strdup(decoded);
295           handled=1;
296           data=nl(data);
297       }
298     }
299     if(filter(data,"a=Copyright:buffer;",&buf, BUFLEN)) {
300       decoded=b64_decode(buf, decoded, &len);
301           if ( decoded != NULL ) {
302           desc->copyright=strdup(decoded);
303           handled=1;
304           data=nl(data);
305       }
306     }
307     if(filter(data,"a=Abstract:buffer;",&buf, BUFLEN)) {
308       decoded=b64_decode(buf, decoded, &len);
309       if ( decoded != NULL ) {
310            desc->abstract=strdup(decoded);
311            handled=1;
312            data=nl(data);
313       }
314     }
315     if(filter(data,"a=StreamCount:integer;",&buf, BUFLEN)) {
316         /* This way negative values are mapped to unfeasibly high
317          * values, and will be discarded afterward
318          */
319         unsigned long tmp = strtoul(buf, NULL, 10);
320         if ( tmp > UINT16_MAX )
321             lprintf("stream count out of bound: %lu\n", tmp);
322         else
323             desc->stream_count = tmp;
324         desc->stream = malloc(sizeof(sdpplin_stream_t*)*desc->stream_count);
325         handled=1;
326         data=nl(data);
327     }
328     if(filter(data,"a=Flags:integer;",&buf, BUFLEN)) {
329       desc->flags=atoi(buf);
330       handled=1;
331       data=nl(data);
332     }
333
334     if(!handled) {
335 #ifdef LOG
336       int len=strchr(data,'\n')-data;
337       memcpy(buf, data, len+1);
338       buf[len]=0;
339       printf("libreal: sdpplin: not handled: '%s'\n", buf);
340 #endif
341       data=nl(data);
342     }
343   }
344
345   free( decoded );
346   free( buf );
347   return desc;
348 }
349
350 void sdpplin_free(sdpplin_t *description) {
351
352   int i;
353
354   if( !description ) return;
355
356   for( i=0; i<description->stream_count; i++ ) {
357     if( description->stream[i] ) {
358       free( description->stream[i]->id );
359       free( description->stream[i]->bandwidth );
360       free( description->stream[i]->range );
361       free( description->stream[i]->length );
362       free( description->stream[i]->rtpmap );
363       free( description->stream[i]->mimetype );
364       free( description->stream[i]->stream_name );
365       free( description->stream[i]->mime_type );
366       free( description->stream[i]->mlti_data );
367       free( description->stream[i]->rmff_flags );
368       free( description->stream[i]->asm_rule_book );
369       free( description->stream[i] );
370     }
371   }
372   if( description->stream_count )
373     free( description->stream );
374
375   free( description->owner );
376   free( description->session_name );
377   free( description->session_info );
378   free( description->uri );
379   free( description->email );
380   free( description->phone );
381   free( description->connection );
382   free( description->bandwidth );
383   free( description->title );
384   free( description->author );
385   free( description->copyright );
386   free( description->keywords );
387   free( description->asm_rule_book );
388   free( description->abstract );
389   free( description->range );
390   free( description );
391 }
392