realrtsp: initialize *all* the array
[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   for (j=0; j<strlen(in); j+=4) {
58     char a[4], b[4];
59
60     for (i = 0; i < 4; i++) {
61       int c = in[i+j];
62
63       if (dtable[c] & 0x80) {
64         printf("Illegal character '%c' in input.\n", c);
65         exit(1);
66       }
67       a[i] = (char) c;
68       b[i] = (char) dtable[c];
69     }
70     //xine_buffer_ensure_size(out, k+3);
71     out[k++] = (b[0] << 2) | (b[1] >> 4);
72     out[k++] = (b[1] << 4) | (b[2] >> 2);
73     out[k++] = (b[2] << 6) | b[3];
74     i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
75     if (i < 3) {
76       out[k]=0;
77       *size=k;
78       return out;
79     }
80   }
81   out[k]=0;
82   *size=k;
83   return out;
84 }
85
86 static char *nl(char *data) {
87
88   char *nlptr = (data) ? strchr(data,'\n') : NULL;
89   return (nlptr) ? nlptr + 1 : NULL;
90 }
91
92 static int filter(const char *in, const char *filter, char **out, size_t outlen) {
93
94   int flen=strlen(filter);
95   size_t len;
96
97   if (!in) return 0;
98
99   len = (strchr(in,'\n')) ? (size_t)(strchr(in,'\n')-in) : strlen(in);
100   if (!strncmp(in,filter,flen)) {
101     if(in[flen]=='"') flen++;
102     if(in[len-1]==13) len--;
103     if(in[len-1]=='"') len--;
104     if( len-flen+1 > outlen )
105     {
106         printf("Discarding end of string to avoid overflow");
107         len=outlen+flen-1;
108     }
109     memcpy(*out, in+flen, len-flen+1);
110     (*out)[len-flen]=0;
111     return len-flen;
112   }
113   return 0;
114 }
115
116 static sdpplin_stream_t *sdpplin_parse_stream(char **data) {
117
118   sdpplin_stream_t *desc;
119   char* buf = NULL;
120   char* decoded = NULL;
121   int handled;
122
123   desc = calloc( 1, sizeof(sdpplin_stream_t) );
124   if( !desc )
125     return NULL;
126
127   buf = malloc( BUFLEN );
128   if( !buf )
129     goto error;
130
131   decoded = malloc( BUFLEN );
132   if( !decoded )
133     goto error;
134
135   if (filter(*data, "m=", &buf, BUFLEN)) {
136     desc->id = strdup(buf);
137   } else {
138     lprintf("sdpplin: no m= found.\n");
139     goto error;
140   }
141   *data=nl(*data);
142
143   while (*data && **data && *data[0]!='m') {
144     handled=0;
145
146     if(filter(*data,"a=control:streamid=",&buf, BUFLEN)) {
147         /* This way negative values are mapped to unfeasibly high
148          * values, and will be discarded afterward
149          */
150         unsigned long tmp = strtoul(buf, NULL, 10);
151         if ( tmp > UINT16_MAX )
152             lprintf("stream id out of bound: %lu\n", tmp);
153         else
154             desc->stream_id=tmp;
155         handled=1;
156         *data=nl(*data);
157     }
158     if(filter(*data,"a=MaxBitRate:integer;",&buf, BUFLEN)) {
159       desc->max_bit_rate=atoi(buf);
160       if (!desc->avg_bit_rate)
161         desc->avg_bit_rate=desc->max_bit_rate;
162       handled=1;
163       *data=nl(*data);
164     }
165     if(filter(*data,"a=MaxPacketSize:integer;",&buf, BUFLEN)) {
166       desc->max_packet_size=atoi(buf);
167       if (!desc->avg_packet_size)
168         desc->avg_packet_size=desc->max_packet_size;
169       handled=1;
170       *data=nl(*data);
171     }
172     if(filter(*data,"a=StartTime:integer;",&buf, BUFLEN)) {
173       desc->start_time=atoi(buf);
174       handled=1;
175       *data=nl(*data);
176     }
177     if(filter(*data,"a=Preroll:integer;",&buf, BUFLEN)) {
178       desc->preroll=atoi(buf);
179       handled=1;
180       *data=nl(*data);
181     }
182     if(filter(*data,"a=length:npt=",&buf, BUFLEN)) {
183       desc->duration=(uint32_t)(atof(buf)*1000);
184       handled=1;
185       *data=nl(*data);
186     }
187     if(filter(*data,"a=StreamName:string;",&buf, BUFLEN)) {
188       desc->stream_name=strdup(buf);
189       desc->stream_name_size=strlen(desc->stream_name);
190       handled=1;
191       *data=nl(*data);
192     }
193     if(filter(*data,"a=mimetype:string;",&buf, BUFLEN)) {
194       desc->mime_type=strdup(buf);
195       desc->mime_type_size=strlen(desc->mime_type);
196       handled=1;
197       *data=nl(*data);
198     }
199     if(filter(*data,"a=OpaqueData:buffer;",&buf, BUFLEN)) {
200       decoded = b64_decode(buf, decoded, &(desc->mlti_data_size));
201       if ( decoded != NULL ) {
202           desc->mlti_data = malloc(desc->mlti_data_size);
203           memcpy(desc->mlti_data, decoded, desc->mlti_data_size);
204           handled=1;
205           *data=nl(*data);
206           lprintf("mlti_data_size: %i\n", desc->mlti_data_size);
207       }
208     }
209     if(filter(*data,"a=ASMRuleBook:string;",&buf, BUFLEN)) {
210       desc->asm_rule_book=strdup(buf);
211       handled=1;
212       *data=nl(*data);
213     }
214
215     if(!handled) {
216 #ifdef LOG
217       int len=strchr(*data,'\n')-(*data);
218       memcpy(buf, *data, len+1);
219       buf[len]=0;
220       printf("libreal: sdpplin: not handled: '%s'\n", buf);
221 #endif
222       *data=nl(*data);
223     }
224   }
225   free( buf );
226   free( decoded) ;
227   return desc;
228
229 error:
230   free( decoded );
231   free( desc );
232   free( buf );
233   return NULL;
234 }
235
236
237 sdpplin_t *sdpplin_parse(char *data)
238 {
239   sdpplin_t*        desc;
240   sdpplin_stream_t* stream;
241   char*             buf;
242   char*             decoded;
243   int               handled;
244   int               len;
245
246   desc = calloc( 1, sizeof(sdpplin_t) );
247   if( !desc )
248     return NULL;
249
250   buf = malloc( BUFLEN );
251   if( !buf )
252   {
253     free( desc );
254     return NULL;
255   }
256
257   decoded = malloc( BUFLEN );
258   if( !decoded )
259   {
260     free( buf );
261     free( desc );
262     return NULL;
263   }
264   desc->stream = NULL;
265
266   while (data && *data) {
267     handled=0;
268
269     if (filter(data, "m=", &buf, BUFLEN)) {
270         if ( !desc->stream ) {
271             fprintf(stderr, "sdpplin.c: stream identifier found before stream count, skipping.");
272             continue;
273         }
274         stream=sdpplin_parse_stream(&data);
275         lprintf("got data for stream id %u\n", stream->stream_id);
276         if ( stream->stream_id >= desc->stream_count )
277             lprintf("stream id %u is greater than stream count %u\n", stream->stream_id, desc->stream_count);
278         else
279             desc->stream[stream->stream_id]=stream;
280         continue;
281     }
282     if(filter(data,"a=Title:buffer;",&buf, BUFLEN)) {
283       decoded=b64_decode(buf, decoded, &len);
284           if ( decoded != NULL ) {
285           desc->title=strdup(decoded);
286           handled=1;
287           data=nl(data);
288       }
289     }
290     if(filter(data,"a=Author:buffer;",&buf, BUFLEN)) {
291       decoded=b64_decode(buf, decoded, &len);
292           if ( decoded != NULL ) {
293           desc->author=strdup(decoded);
294           handled=1;
295           data=nl(data);
296       }
297     }
298     if(filter(data,"a=Copyright:buffer;",&buf, BUFLEN)) {
299       decoded=b64_decode(buf, decoded, &len);
300           if ( decoded != NULL ) {
301           desc->copyright=strdup(decoded);
302           handled=1;
303           data=nl(data);
304       }
305     }
306     if(filter(data,"a=Abstract:buffer;",&buf, BUFLEN)) {
307       decoded=b64_decode(buf, decoded, &len);
308       if ( decoded != NULL ) {
309            desc->abstract=strdup(decoded);
310            handled=1;
311            data=nl(data);
312       }
313     }
314     if(filter(data,"a=StreamCount:integer;",&buf, BUFLEN)) {
315         /* This way negative values are mapped to unfeasibly high
316          * values, and will be discarded afterward
317          */
318         unsigned long tmp = strtoul(buf, NULL, 10);
319         if ( tmp > UINT16_MAX )
320             lprintf("stream count out of bound: %lu\n", tmp);
321         else
322             desc->stream_count = tmp;
323         desc->stream = malloc(sizeof(sdpplin_stream_t*)*desc->stream_count);
324         handled=1;
325         data=nl(data);
326     }
327     if(filter(data,"a=Flags:integer;",&buf, BUFLEN)) {
328       desc->flags=atoi(buf);
329       handled=1;
330       data=nl(data);
331     }
332
333     if(!handled) {
334 #ifdef LOG
335       int len=strchr(data,'\n')-data;
336       memcpy(buf, data, len+1);
337       buf[len]=0;
338       printf("libreal: sdpplin: not handled: '%s'\n", buf);
339 #endif
340       data=nl(data);
341     }
342   }
343
344   free( decoded );
345   free( buf );
346   return desc;
347 }
348
349 void sdpplin_free(sdpplin_t *description) {
350
351   int i;
352
353   if( !description ) return;
354
355   for( i=0; i<description->stream_count; i++ ) {
356     if( description->stream[i] ) {
357       free( description->stream[i]->id );
358       free( description->stream[i]->bandwidth );
359       free( description->stream[i]->range );
360       free( description->stream[i]->length );
361       free( description->stream[i]->rtpmap );
362       free( description->stream[i]->mimetype );
363       free( description->stream[i]->stream_name );
364       free( description->stream[i]->mime_type );
365       free( description->stream[i]->mlti_data );
366       free( description->stream[i]->rmff_flags );
367       free( description->stream[i]->asm_rule_book );
368       free( description->stream[i] );
369     }
370   }
371   if( description->stream_count )
372     free( description->stream );
373
374   free( description->owner );
375   free( description->session_name );
376   free( description->session_info );
377   free( description->uri );
378   free( description->email );
379   free( description->phone );
380   free( description->connection );
381   free( description->bandwidth );
382   free( description->title );
383   free( description->author );
384   free( description->copyright );
385   free( description->keywords );
386   free( description->asm_rule_book );
387   free( description->abstract );
388   free( description->range );
389   free( description );
390 }