]> git.sesse.net Git - vlc/blob - include/network.h
Compile fix
[vlc] / include / network.h
1 /*****************************************************************************
2  * network.h: interface to communicate with network plug-ins
3  *****************************************************************************
4  * Copyright (C) 2002-2005 VideoLAN
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *          RĂ©mi Denis-Courmont <rem # videolan.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 #ifndef __VLC_NETWORK_H
27 # define __VLC_NETWORK_H
28
29 #ifdef HAVE_SYS_SOCKET_H
30     #include <sys/socket.h>
31 #endif
32
33 /*****************************************************************************
34  * network_socket_t: structure passed to a network plug-in to define the
35  *                   kind of socket we want
36  *****************************************************************************/
37 struct network_socket_t
38 {
39     char * psz_bind_addr;
40     int i_bind_port;
41
42     char * psz_server_addr;
43     int i_server_port;
44
45     int i_ttl;
46
47     /* Return values */
48     int i_handle;
49     size_t i_mtu;
50 };
51
52 typedef struct
53 {
54     char *psz_protocol;
55     char *psz_username;
56     char *psz_password;
57     char *psz_host;
58     int  i_port;
59
60     char *psz_path;
61
62     char *psz_option;
63     
64     char *psz_buffer; /* to be freed */
65 } vlc_url_t;
66
67 /*****************************************************************************
68  * vlc_UrlParse:
69  *****************************************************************************
70  * option : if != 0 then path is split at this char
71  *
72  * format [protocol://[login[:password]@]][host[:port]]/path[OPTIONoption]
73  *****************************************************************************/
74 static inline void vlc_UrlParse( vlc_url_t *url, const char *psz_url,
75                                  char option )
76 {
77     char *psz_dup;
78     char *psz_parse;
79     char *p;
80
81     url->psz_protocol = NULL;
82     url->psz_username = NULL;
83     url->psz_password = NULL;
84     url->psz_host     = NULL;
85     url->i_port       = 0;
86     url->psz_path     = NULL;
87     url->psz_option   = NULL;
88     
89     if( psz_url == NULL )
90     {
91         url->psz_buffer = NULL;
92         return;
93     }
94     url->psz_buffer = psz_parse = psz_dup = strdup( psz_url );
95
96     p  = strstr( psz_parse, ":/" );
97     if( p != NULL )
98     {
99         /* we have a protocol */
100
101         /* skip :// */
102         *p++ = '\0';
103         if( p[1] == '/' )
104             p += 2;
105         url->psz_protocol = psz_parse;
106
107         psz_parse = p;
108         p = strchr( psz_parse, '@' );
109         if( p != NULL )
110         {
111             /* We have a login */
112             url->psz_username = psz_parse;
113             *p++ = '\0';
114
115             psz_parse = strchr( psz_parse, ':' );
116             if( psz_parse != NULL )
117             {
118                 /* We have a password */
119                 *psz_parse++ = '\0';
120                 url->psz_password = psz_parse;
121             }
122
123             psz_parse = p;
124         }
125     }
126
127     p = strchr( psz_parse, '/' );
128     if( !p || psz_parse < p )
129     {
130         char *p2;
131
132         /* We have a host[:port] */
133         url->psz_host = strdup( psz_parse );
134         if( p )
135         {
136             url->psz_host[p - psz_parse] = '\0';
137         }
138
139         if( *url->psz_host == '[' )
140         {
141             /* Ipv6 address */
142             p2 = strchr( url->psz_host, ']' );
143             if( p2 )
144             {
145                 p2 = strchr( p2, ':' );
146             }
147         }
148         else
149         {
150             p2 = strchr( url->psz_host, ':' );
151         }
152         if( p2 )
153         {
154             *p2++ = '\0';
155             url->i_port = atoi( p2 );
156         }
157     }
158     psz_parse = p;
159
160     /* Now parse psz_path and psz_option */
161     if( psz_parse )
162     {
163         url->psz_path = psz_parse;
164         if( option != '\0' )
165         {
166             p = strchr( url->psz_path, option );
167             if( p )
168             {
169                 *p++ = '\0';
170                 url->psz_option = p;
171             }
172         }
173     }
174 }
175
176 /*****************************************************************************
177  * vlc_UrlClean:
178  *****************************************************************************
179  *
180  *****************************************************************************/
181 static inline void vlc_UrlClean( vlc_url_t *url )
182 {
183     if( url->psz_buffer ) free( url->psz_buffer );
184     if( url->psz_host )   free( url->psz_host );
185
186     url->psz_protocol = NULL;
187     url->psz_username = NULL;
188     url->psz_password = NULL;
189     url->psz_host     = NULL;
190     url->i_port       = 0;
191     url->psz_path     = NULL;
192     url->psz_option   = NULL;
193
194     url->psz_buffer   = NULL;
195 }
196
197 /*****************************************************************************
198  * vlc_UrlEncode: 
199  *****************************************************************************
200  * perform URL encoding
201  * (you do NOT want to do URL decoding - it is not reversible - do NOT do it)
202  *****************************************************************************/
203 static inline char *vlc_UrlEncode( const char *psz_url )
204 {
205     char *psz_enc, *out;
206     const char *in;
207
208     psz_enc = (char *)malloc( 3 * strlen( psz_url ) + 1 );
209     if( psz_enc == NULL )
210         return NULL;
211
212     out = psz_enc;
213     for( in = psz_url; *in; in++ )
214     {
215         char c = *in;
216
217         if( ( c <= 32 ) || ( c == '%' ) || ( c == '?' ) || ( c == '&' )
218          || ( c == '+' ) )
219         {
220             *out++ = '%';   
221             *out++ = ( ( c >> 4 ) >= 0xA ) ? 'A' + ( c >> 4 ) - 0xA
222                                            : '0' + ( c >> 4 );
223             *out++ = ( ( c & 0xf ) >= 0xA ) ? 'A' + ( c & 0xf ) - 0xA
224                                            : '0' + ( c & 0xf );
225         }
226         else
227             *out++ = c;
228     }
229     *out++ = '\0';
230
231     return (char *)realloc( psz_enc, out - psz_enc );
232 }
233
234 /*****************************************************************************
235  * vlc_UrlIsNotEncoded:
236  *****************************************************************************
237  * check if given string is not a valid URL and must hence be encoded
238  *****************************************************************************/
239 #include <ctype.h>
240
241 static inline int vlc_UrlIsNotEncoded( const char *psz_url )
242 {
243     const char *ptr;
244
245     for( ptr = psz_url; *ptr; ptr++ )
246     {
247         char c = *ptr;
248
249         if( c == '%' )
250         {
251             if( !isxdigit( ptr[1] ) || !isxdigit( ptr[2] ) )
252                 return 1; /* not encoded */
253             ptr += 2;
254         }
255         else
256         if( c == ' ' )
257             return 1;
258     }
259     return 0; /* looks fine - but maybe it is not encoded */
260 }
261                     
262 /*****************************************************************************
263  * vlc_b64_encode:
264  *****************************************************************************
265  *
266  *****************************************************************************/
267 static inline char *vlc_b64_encode( char *src )
268 {
269     static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
270                                                                                 
271     char *dst = (char *)malloc( strlen( src ) * 4 / 3 + 12 );
272     char *ret = dst;
273     unsigned i_bits = 0;
274     unsigned i_shift = 0;
275                                                                                 
276     for( ;; )
277     {
278         if( *src )
279         {
280             i_bits = ( i_bits << 8 )|( *src++ );
281             i_shift += 8;
282         }
283         else if( i_shift > 0 )
284         {
285            i_bits <<= 6 - i_shift;
286            i_shift = 6;
287         }
288         else
289         {
290             *dst++ = '=';
291             break;
292         }
293                                                                                 
294         while( i_shift >= 6 )
295         {
296             i_shift -= 6;
297             *dst++ = b64[(i_bits >> i_shift)&0x3f];
298         }
299     }
300                                                                                 
301     *dst++ = '\0';
302                                                                                 
303     return ret;
304 }
305
306 /* Portable networking layer communication */
307 #define net_OpenTCP(a, b, c) __net_OpenTCP(VLC_OBJECT(a), b, c)
308 VLC_EXPORT( int, __net_OpenTCP, ( vlc_object_t *p_this, const char *psz_host, int i_port ) );
309
310 #define net_ListenTCP(a, b, c) __net_ListenTCP(VLC_OBJECT(a), b, c)
311 VLC_EXPORT( int *, __net_ListenTCP, ( vlc_object_t *, const char *, int ) );
312
313 #define net_Accept(a, b, c) __net_Accept(VLC_OBJECT(a), b, c)
314 VLC_EXPORT( int, __net_Accept, ( vlc_object_t *, int *, mtime_t ) );
315
316 #define net_OpenUDP(a, b, c, d, e ) __net_OpenUDP(VLC_OBJECT(a), b, c, d, e)
317 VLC_EXPORT( int, __net_OpenUDP, ( vlc_object_t *p_this, char *psz_bind, int i_bind, char *psz_server, int i_server ) );
318
319 VLC_EXPORT( void, net_Close, ( int fd ) );
320 VLC_EXPORT( void, net_ListenClose, ( int *fd ) );
321
322
323 /* Functions to read from or write to the networking layer */
324 struct virtual_socket_t
325 {
326     void *p_sys;
327     int (*pf_recv) ( void *, void *, int );
328     int (*pf_send) ( void *, const void *, int );
329 };
330
331 #define net_Read(a,b,c,d,e,f) __net_Read(VLC_OBJECT(a),b,c,d,e,f)
332 VLC_EXPORT( int, __net_Read, ( vlc_object_t *p_this, int fd, v_socket_t *, uint8_t *p_data, int i_data, vlc_bool_t b_retry ) );
333
334 #define net_ReadNonBlock(a,b,c,d,e,f) __net_ReadNonBlock(VLC_OBJECT(a),b,c,d,e,f)
335 VLC_EXPORT( int, __net_ReadNonBlock, ( vlc_object_t *p_this, int fd, v_socket_t *, uint8_t *p_data, int i_data, mtime_t i_wait ) );
336
337 #define net_Select(a,b,c,d,e,f,g) __net_Select(VLC_OBJECT(a),b,c,d,e,f,g)
338 VLC_EXPORT( int, __net_Select, ( vlc_object_t *p_this, int *pi_fd, v_socket_t **, int i_fd, uint8_t *p_data, int i_data, mtime_t i_wait ) );
339
340 #define net_Write(a,b,c,d,e) __net_Write(VLC_OBJECT(a),b,c,d,e)
341 VLC_EXPORT( int, __net_Write, ( vlc_object_t *p_this, int fd, v_socket_t *, uint8_t *p_data, int i_data ) );
342
343 #define net_Gets(a,b,c) __net_Gets(VLC_OBJECT(a),b,c)
344 VLC_EXPORT( char *, __net_Gets, ( vlc_object_t *p_this, int fd, v_socket_t * ) );
345
346 VLC_EXPORT( int, net_Printf, ( vlc_object_t *p_this, int fd, v_socket_t *, const char *psz_fmt, ... ) );
347
348 #define net_vaPrintf(a,b,c,d,e) __net_vaPrintf(VLC_OBJECT(a),b,c,d,e)
349 VLC_EXPORT( int, __net_vaPrintf, ( vlc_object_t *p_this, int fd, v_socket_t *, const char *psz_fmt, va_list args ) );
350
351 /*****************************************************************************
352  * net_StopRecv/Send
353  *****************************************************************************
354  * Wrappers for shutdown()
355  *****************************************************************************/
356 #if defined (SHUT_WR)
357 /* the standard way */
358 # define net_StopSend( fd ) shutdown( fd, SHUT_WR )
359 # define net_StopRecv( fd ) shutdown( fd, SHUT_RD )
360 #elif defined (SD_SEND)
361 /* the Microsoft seemingly-purposedly-different-for-the-sake-of-it way */
362 # define net_StopSend( fd ) shutdown( fd, SD_SEND )
363 # define net_StopRecv( fd ) shutdown( fd, SD_RECEIVE )
364 #else
365 # warning FIXME: implement shutdown on your platform!
366 # define net_StopSend( fd ) return(-1) 
367 # define net_StopRecv( fd ) return(-1)
368 #endif
369
370 #define net_CheckIP(a,b,c,d) __net_CheckIP(VLC_OBJECT(a),b,c,d)
371 VLC_EXPORT( int, __net_CheckIP, ( vlc_object_t *p_this, char *psz_ip, char **ppsz_hosts, int i_hosts ) );
372
373 /* Portable network names/addresses resolution layer */
374
375 /* GAI error codes */
376 # ifndef EAI_BADFLAGS
377 #  define EAI_BADFLAGS -1
378 # endif
379 # ifndef EAI_NONAME
380 #  define EAI_NONAME -2
381 # endif
382 # ifndef EAI_AGAIN
383 #  define EAI_AGAIN -3
384 # endif
385 # ifndef EAI_FAIL
386 #  define EAI_FAIL -4
387 # endif
388 # ifndef EAI_NODATA
389 #  define EAI_NODATA -5
390 # endif
391 # ifndef EAI_FAMILY
392 #  define EAI_FAMILY -6
393 # endif
394 # ifndef EAI_SOCKTYPE
395 #  define EAI_SOCKTYPE -7
396 # endif
397 # ifndef EAI_SERVICE
398 #  define EAI_SERVICE -8
399 # endif
400 # ifndef EAI_ADDRFAMILY
401 #  define EAI_ADDRFAMILY -9
402 # endif
403 # ifndef EAI_MEMORY
404 #  define EAI_MEMORY -10
405 # endif
406 # ifndef EAI_SYSTEM
407 #  define EAI_SYSTEM -11
408 # endif
409
410
411 # ifndef NI_MAXHOST
412 #  define NI_MAXHOST 1025
413 #  define NI_MAXSERV 32
414 # endif
415 # define NI_MAXNUMERICHOST 48
416
417 # ifndef NI_NUMERICHOST
418 #  define NI_NUMERICHOST 0x01
419 #  define NI_NUMERICSERV 0x02
420 #  define NI_NOFQDN      0x04
421 #  define NI_NAMEREQD    0x08
422 #  define NI_DGRAM       0x10
423 # endif
424
425 # ifndef HAVE_STRUCT_ADDRINFO
426 struct addrinfo
427 {
428     int ai_flags;
429     int ai_family;
430     int ai_socktype;
431     int ai_protocol;
432     size_t ai_addrlen;
433     struct sockaddr *ai_addr;
434     char *ai_canonname;
435     struct addrinfo *ai_next;
436 };
437 #  define AI_PASSIVE     1
438 #  define AI_CANONNAME   2
439 #  define AI_NUMERICHOST 4
440 # endif /* if !HAVE_STRUCT_ADDRINFO */
441
442 /*** libidn support ***/
443 # ifndef AI_IDN
444 #  define AI_IDN      0
445 #  define AI_CANONIDN 0
446 # endif
447
448 VLC_EXPORT( const char *, vlc_gai_strerror, ( int ) );
449 VLC_EXPORT( int, vlc_getnameinfo, ( const struct sockaddr *, int, char *, int, int *, int ) );
450 VLC_EXPORT( int, vlc_getaddrinfo, ( vlc_object_t *, const char *, int, const struct addrinfo *, struct addrinfo ** ) );
451 VLC_EXPORT( void, vlc_freeaddrinfo, ( struct addrinfo * ) );
452
453 #endif