tags/1.0b/conn.c

  /********************************************************************\
  * Axel -- A lighter download accelerator for Linux and other Unices. *
  *                                                                    *
  * Copyright 2001 Wilmer van der Gaast                                *
  \********************************************************************/

/* Connection stuff                                                     */

/*
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License with
  the Debian GNU/Linux distribution in file /usr/doc/copyright/GPL;
  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
  Suite 330, Boston, MA  02111-1307  USA
*/

#include "axel.h"

char string[MAX_STRING];

/* Convert an URL to a conn_t structure                                 */
int conn_set( conn_t *conn, char *set_url )
{
        char url[MAX_STRING];
        char *i, *j;
        
        /* protocol://                                                  */
        if( ( i = strstr( set_url, "://" ) ) == NULL )
        {
                conn->proto = PROTO_DEFAULT;
                strncpy( url, set_url, MAX_STRING );
        }
        else
        {
                if( set_url[0] == 'f' )
                        conn->proto = PROTO_FTP;
                else if( set_url[0] == 'h' )
                        conn->proto = PROTO_HTTP;
                else
                {
                        return( 0 );
                }
                strncpy( url, i + 3, MAX_STRING );
        }
        
        /* Split                                                        */
        if( ( i = strchr( url, '/' ) ) == NULL )
        {
                strcpy( conn->dir, "/" );
        }
        else
        {
                *i = 0;
                snprintf( conn->dir, MAX_STRING, "/%s", i + 1 );
                if( conn->proto == PROTO_HTTP )
                        http_encode( conn->dir );
        }
        strncpy( conn->host, url, MAX_STRING );
        j = strchr( conn->dir, '?' );
        if( j != NULL )
                *j = 0;
        i = strrchr( conn->dir, '/' );
        *i = 0;
        if( j != NULL )
                *j = '?';
        if( i == NULL )
        {
                strcpy( conn->file, conn->dir );
                strcpy( conn->dir, "/" );
        }
        else
        {
                strcpy( conn->file, i + 1 );
                strcat( conn->dir, "/" );
        }
        
        /* Check for username in host field                             */
        if( strrchr( conn->host, '@' ) != NULL )
        {
                strncpy( conn->user, conn->host, MAX_STRING );
                i = strrchr( conn->user, '@' );
                *i = 0;
                strcpy( conn->host, i + 1 );
                *conn->pass = 0;
        }
        /* If not: Fill in defaults                                     */
        else
        {
                if( conn->proto == PROTO_FTP )
                {
                        /* Dash the password: Save traffic by trying
                           to avoid multi-line responses                */
                        strcpy( conn->user, "anonymous" );
                        strcpy( conn->pass, "-lara_hack@gmx.co.uk" );
                }
                else
                {
                        *conn->user = *conn->pass = 0;
                }
        }
        
        /* Password?                                                    */
        if( ( i = strchr( conn->user, ':' ) ) != NULL )
        {
                *i = 0;
                strcpy( conn->pass, i + 1 );
        }
        /* Port number?                                                 */
        if( ( i = strchr( conn->host, ':' ) ) != NULL )
        {
                *i = 0;
                sscanf( i + 1, "%i", &conn->port );
        }
        /* Take default port numbers from /etc/services                 */
        else
        {
#ifndef DARWIN
                struct servent *serv;
                
                if( conn->proto == PROTO_FTP )
                        serv = getservbyname( "ftp", "tcp" );
                else
                        serv = getservbyname( "www", "tcp" );
                
                if( serv )
                        conn->port = ntohs( serv->s_port );
                else
#endif
                if( conn->proto == PROTO_HTTP )
                        conn->port = 80;
                else
                        conn->port = 21;
        }
        
        return( conn->port > 0 );
}

/* Generate a nice URL string.                                          */
char *conn_url( conn_t *conn )
{
        if( conn->proto == PROTO_FTP )
                strcpy( string, "ftp://" );
        else
                strcpy( string, "http://" );
        
        if( *conn->user != 0 && strcmp( conn->user, "anonymous" ) != 0 )
                sprintf( string + strlen( string ), "%s:%s@",
                        conn->user, conn->pass );

        sprintf( string + strlen( string ), "%s:%i%s%s",
                conn->host, conn->port, conn->dir, conn->file );
        
        return( string );
}

/* Simple...                                                            */
void conn_disconnect( conn_t *conn )
{
        if( conn->proto == PROTO_FTP && !conn->proxy )
                ftp_disconnect( conn->ftp );
        else
                http_disconnect( conn->http );
        conn->fd = -1;
}

int conn_init( conn_t *conn )
{
        char *proxy = conn->conf->http_proxy, *host = conn->conf->no_proxy;
        int i;
        
        if( *conn->conf->http_proxy == 0 )
        {
                proxy = NULL;
        }
        else if( *conn->conf->no_proxy != 0 )
        {
                for( i = 0; ; i ++ )
                        if( conn->conf->no_proxy[i] == 0 )
                        {
                                if( strstr( conn->host, host ) != NULL )
                                        proxy = NULL;
                                host = &conn->conf->no_proxy[i+1];
                                if( conn->conf->no_proxy[i+1] == 0 )
                                        break;
                        }
        }
        
        conn->proxy = proxy != NULL;
        
        if( conn->proto == PROTO_FTP && !conn->proxy )
        {
                conn->ftp->local_if = conn->local_if;
                conn->ftp->ftp_mode = FTP_PASSIVE;
                if( !ftp_connect( conn->ftp, conn->host, conn->port, conn->user, conn->pass ) )
                {
                        conn->message = conn->ftp->message;
                        conn_disconnect( conn );
                        return( 0 );
                }
                conn->message = conn->ftp->message;
                if( !ftp_cwd( conn->ftp, conn->dir ) )
                {
                        conn_disconnect( conn );
                        return( 0 );
                }
        }
        else
        {
                conn->http->local_if = conn->local_if;
                if( !http_connect( conn->http, conn->proto, proxy, conn->host, conn->port, conn->user, conn->pass ) )
                {
                        conn->message = conn->http->headers;
                        conn_disconnect( conn );
                        return( 0 );
                }
                conn->message = conn->http->headers;
                conn->fd = conn->http->fd;
        }
        return( 1 );
}

int conn_setup( conn_t *conn )
{
        if( conn->ftp->fd <= 0 && conn->http->fd <= 0 )
                if( !conn_init( conn ) )
                        return( 0 );
        
        if( conn->proto == PROTO_FTP && !conn->proxy )
        {
                if( !ftp_data( conn->ftp ) )    /* Set up data connnection      */
                        return( 0 );
                conn->fd = conn->ftp->data_fd;
                
                if( conn->currentbyte )
                {
                        ftp_command( conn->ftp, "REST %i", conn->currentbyte );
                        if( ftp_wait( conn->ftp ) / 100 != 3 &&
                            conn->ftp->status / 100 != 2 )
                                return( 0 );
                }
        }
        else
        {
                char s[MAX_STRING];
                
                snprintf( s, MAX_STRING, "%s%s", conn->dir, conn->file );
                conn->http->firstbyte = conn->currentbyte;
                conn->http->lastbyte = conn->lastbyte;
                http_get( conn->http, s );
        }
        return( 1 );
}

int conn_exec( conn_t *conn )
{
        if( conn->proto == PROTO_FTP && !conn->proxy )
        {
                if( !ftp_command( conn->ftp, "RETR %s", conn->file ) )
                        return( 0 );
                return( ftp_wait( conn->ftp ) / 100 == 1 );
        }
        else
        {
                if( !http_exec( conn->http ) )
                        return( 0 );
                return( conn->http->status / 100 == 2 );
        }
}

/* Get file size and other information                                  */
int conn_info( conn_t *conn )
{
        /* It's all a bit messed up.. But it works.                     */
        if( conn->proto == PROTO_FTP && !conn->proxy )
        {
                ftp_command( conn->ftp, "REST %i", 1 );
                if( ftp_wait( conn->ftp ) / 100 == 3 ||
                    conn->ftp->status / 100 == 2 )
                {
                        conn->supported = 1;
                        ftp_command( conn->ftp, "REST %i", 0 );
                        ftp_wait( conn->ftp );
                }
                else
                {
                        conn->supported = 0;
                }
                
                if( !ftp_cwd( conn->ftp, conn->dir ) )
                        return( 0 );
                conn->size = ftp_size( conn->ftp, conn->file, MAX_REDIR );
                if( conn->size < 0 )
                        conn->supported = 0;
                if( conn->size == -1 )
                        return( 0 );
                else if( conn->size == -2 )
                        conn->size = INT_MAX;
        }
        else
        {
                char s[MAX_STRING], *t;
                int i = 0;
                
                do
                {
                        conn->currentbyte = 1;
                        conn_setup( conn );
                        conn_exec( conn );
                        conn_disconnect( conn );
                        /* Code 3xx == redirect                         */
                        if( conn->http->status / 100 != 3 )
                                break;
                        if( ( t = http_header( conn->http, "location:" ) ) == NULL )
                                return( 0 );
                        sscanf( t, "%255s", s );
                        if( strstr( s, "://" ) == NULL)
                        {
                                sprintf( conn->http->headers, "%s%s",
                                        conn_url( conn ), s );
                                strncpy( s, conn->http->headers, MAX_STRING );
                        }
                        else if( s[0] == '/' )
                        {
                                sprintf( conn->http->headers, "http://%s:%i%s",
                                        conn->host, conn->port, s );
                                strncpy( s, conn->http->headers, MAX_STRING );
                        }
                        conn_set( conn, s );
                        i ++;
                }
                while( conn->http->status / 100 == 3 && i < MAX_REDIR );
                
                if( i == MAX_REDIR )
                {
                        sprintf( conn->message, _("Too many redirects.\n") );
                        return( 0 );
                }
                
                conn->size = http_size( conn->http );
                if( conn->http->status == 206 && conn->size >= 0 )
                {
                        conn->supported = 1;
                        conn->size ++;
                }
                else if( conn->http->status == 200 || conn->http->status == 206 )
                {
                        conn->supported = 0;
                        conn->size = INT_MAX;
                }
                else
                {
                        t = strchr( conn->message, '\n' );
                        if( t == NULL )
                                sprintf( conn->message, _("Unknown HTTP error.\n") );
                        else
                                *t = 0;
                        return( 0 );
                }
        }
        
        return( 1 );
}
1	appaji-guest	2	/********************************************************************\
2			* Axel -- A lighter download accelerator for Linux and other Unices. *
3			* *
4			* Copyright 2001 Wilmer van der Gaast *
5			\********************************************************************/
6
7			/* Connection stuff */
8
9			/*
10			This program is free software; you can redistribute it and/or modify
11			it under the terms of the GNU General Public License as published by
12			the Free Software Foundation; either version 2 of the License, or
13			(at your option) any later version.
14
15			This program is distributed in the hope that it will be useful,
16			but WITHOUT ANY WARRANTY; without even the implied warranty of
17			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			GNU General Public License for more details.
19
20			You should have received a copy of the GNU General Public License with
21			the Debian GNU/Linux distribution in file /usr/doc/copyright/GPL;
22			if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23			Suite 330, Boston, MA 02111-1307 USA
24			*/
25
26			#include "axel.h"
27
28			char string[MAX_STRING];
29
30			/* Convert an URL to a conn_t structure */
31			int conn_set( conn_t conn, char set_url )
32			{
33			char url[MAX_STRING];
34			char i, j;
35
36			/* protocol:// */
37			if( ( i = strstr( set_url, "://" ) ) == NULL )
38			{
39			conn->proto = PROTO_DEFAULT;
40			strncpy( url, set_url, MAX_STRING );
41			}
42			else
43			{
44			if( set_url[0] == 'f' )
45			conn->proto = PROTO_FTP;
46			else if( set_url[0] == 'h' )
47			conn->proto = PROTO_HTTP;
48			else
49			{
50			return( 0 );
51			}
52			strncpy( url, i + 3, MAX_STRING );
53			}
54
55			/* Split */
56			if( ( i = strchr( url, '/' ) ) == NULL )
57			{
58			strcpy( conn->dir, "/" );
59			}
60			else
61			{
62			*i = 0;
63			snprintf( conn->dir, MAX_STRING, "/%s", i + 1 );
64			if( conn->proto == PROTO_HTTP )
65			http_encode( conn->dir );
66			}
67			strncpy( conn->host, url, MAX_STRING );
68			j = strchr( conn->dir, '?' );
69			if( j != NULL )
70			*j = 0;
71			i = strrchr( conn->dir, '/' );
72			*i = 0;
73			if( j != NULL )
74			*j = '?';
75			if( i == NULL )
76			{
77			strcpy( conn->file, conn->dir );
78			strcpy( conn->dir, "/" );
79			}
80			else
81			{
82			strcpy( conn->file, i + 1 );
83			strcat( conn->dir, "/" );
84			}
85
86			/* Check for username in host field */
87			if( strrchr( conn->host, '@' ) != NULL )
88			{
89			strncpy( conn->user, conn->host, MAX_STRING );
90			i = strrchr( conn->user, '@' );
91			*i = 0;
92			strcpy( conn->host, i + 1 );
93			*conn->pass = 0;
94			}
95			/* If not: Fill in defaults */
96			else
97			{
98			if( conn->proto == PROTO_FTP )
99			{
100			/* Dash the password: Save traffic by trying
101			to avoid multi-line responses */
102			strcpy( conn->user, "anonymous" );
103			strcpy( conn->pass, "-lara_hack@gmx.co.uk" );
104			}
105			else
106			{
107			conn->user = conn->pass = 0;
108			}
109			}
110
111			/* Password? */
112			if( ( i = strchr( conn->user, ':' ) ) != NULL )
113			{
114			*i = 0;
115			strcpy( conn->pass, i + 1 );
116			}
117			/* Port number? */
118			if( ( i = strchr( conn->host, ':' ) ) != NULL )
119			{
120			*i = 0;
121			sscanf( i + 1, "%i", &conn->port );
122			}
123			/* Take default port numbers from /etc/services */
124			else
125			{
126			#ifndef DARWIN
127			struct servent *serv;
128
129			if( conn->proto == PROTO_FTP )
130			serv = getservbyname( "ftp", "tcp" );
131			else
132			serv = getservbyname( "www", "tcp" );
133
134			if( serv )
135			conn->port = ntohs( serv->s_port );
136			else
137			#endif
138			if( conn->proto == PROTO_HTTP )
139			conn->port = 80;
140			else
141			conn->port = 21;
142			}
143
144			return( conn->port > 0 );
145			}
146
147			/* Generate a nice URL string. */
148			char conn_url( conn_t conn )
149			{
150			if( conn->proto == PROTO_FTP )
151			strcpy( string, "ftp://" );
152			else
153			strcpy( string, "http://" );
154
155			if( *conn->user != 0 && strcmp( conn->user, "anonymous" ) != 0 )
156			sprintf( string + strlen( string ), "%s:%s@",
157			conn->user, conn->pass );
158
159			sprintf( string + strlen( string ), "%s:%i%s%s",
160			conn->host, conn->port, conn->dir, conn->file );
161
162			return( string );
163			}
164
165			/* Simple... */
166			void conn_disconnect( conn_t *conn )
167			{
168			if( conn->proto == PROTO_FTP && !conn->proxy )
169			ftp_disconnect( conn->ftp );
170			else
171			http_disconnect( conn->http );
172			conn->fd = -1;
173			}
174
175			int conn_init( conn_t *conn )
176			{
177			char proxy = conn->conf->http_proxy, host = conn->conf->no_proxy;
178			int i;
179
180			if( *conn->conf->http_proxy == 0 )
181			{
182			proxy = NULL;
183			}
184			else if( *conn->conf->no_proxy != 0 )
185			{
186			for( i = 0; ; i ++ )
187			if( conn->conf->no_proxy[i] == 0 )
188			{
189			if( strstr( conn->host, host ) != NULL )
190			proxy = NULL;
191			host = &conn->conf->no_proxy[i+1];
192			if( conn->conf->no_proxy[i+1] == 0 )
193			break;
194			}
195			}
196
197			conn->proxy = proxy != NULL;
198
199			if( conn->proto == PROTO_FTP && !conn->proxy )
200			{
201			conn->ftp->local_if = conn->local_if;
202			conn->ftp->ftp_mode = FTP_PASSIVE;
203			if( !ftp_connect( conn->ftp, conn->host, conn->port, conn->user, conn->pass ) )
204			{
205			conn->message = conn->ftp->message;
206			conn_disconnect( conn );
207			return( 0 );
208			}
209			conn->message = conn->ftp->message;
210			if( !ftp_cwd( conn->ftp, conn->dir ) )
211			{
212			conn_disconnect( conn );
213			return( 0 );
214			}
215			}
216			else
217			{
218			conn->http->local_if = conn->local_if;
219			if( !http_connect( conn->http, conn->proto, proxy, conn->host, conn->port, conn->user, conn->pass ) )
220			{
221			conn->message = conn->http->headers;
222			conn_disconnect( conn );
223			return( 0 );
224			}
225			conn->message = conn->http->headers;
226			conn->fd = conn->http->fd;
227			}
228			return( 1 );
229			}
230
231			int conn_setup( conn_t *conn )
232			{
233			if( conn->ftp->fd <= 0 && conn->http->fd <= 0 )
234			if( !conn_init( conn ) )
235			return( 0 );
236
237			if( conn->proto == PROTO_FTP && !conn->proxy )
238			{
239			if( !ftp_data( conn->ftp ) ) /* Set up data connnection */
240			return( 0 );
241			conn->fd = conn->ftp->data_fd;
242
243			if( conn->currentbyte )
244			{
245			ftp_command( conn->ftp, "REST %i", conn->currentbyte );
246			if( ftp_wait( conn->ftp ) / 100 != 3 &&
247			conn->ftp->status / 100 != 2 )
248			return( 0 );
249			}
250			}
251			else
252			{
253			char s[MAX_STRING];
254
255			snprintf( s, MAX_STRING, "%s%s", conn->dir, conn->file );
256			conn->http->firstbyte = conn->currentbyte;
257			conn->http->lastbyte = conn->lastbyte;
258			http_get( conn->http, s );
259			}
260			return( 1 );
261			}
262
263			int conn_exec( conn_t *conn )
264			{
265			if( conn->proto == PROTO_FTP && !conn->proxy )
266			{
267			if( !ftp_command( conn->ftp, "RETR %s", conn->file ) )
268			return( 0 );
269			return( ftp_wait( conn->ftp ) / 100 == 1 );
270			}
271			else
272			{
273			if( !http_exec( conn->http ) )
274			return( 0 );
275			return( conn->http->status / 100 == 2 );
276			}
277			}
278
279			/* Get file size and other information */
280			int conn_info( conn_t *conn )
281			{
282			/* It's all a bit messed up.. But it works. */
283			if( conn->proto == PROTO_FTP && !conn->proxy )
284			{
285			ftp_command( conn->ftp, "REST %i", 1 );
286			if( ftp_wait( conn->ftp ) / 100 == 3 \|\|
287			conn->ftp->status / 100 == 2 )
288			{
289			conn->supported = 1;
290			ftp_command( conn->ftp, "REST %i", 0 );
291			ftp_wait( conn->ftp );
292			}
293			else
294			{
295			conn->supported = 0;
296			}
297
298			if( !ftp_cwd( conn->ftp, conn->dir ) )
299			return( 0 );
300			conn->size = ftp_size( conn->ftp, conn->file, MAX_REDIR );
301			if( conn->size < 0 )
302			conn->supported = 0;
303			if( conn->size == -1 )
304			return( 0 );
305			else if( conn->size == -2 )
306			conn->size = INT_MAX;
307			}
308			else
309			{
310			char s[MAX_STRING], *t;
311			int i = 0;
312
313			do
314			{
315			conn->currentbyte = 1;
316			conn_setup( conn );
317			conn_exec( conn );
318			conn_disconnect( conn );
319			/* Code 3xx == redirect */
320			if( conn->http->status / 100 != 3 )
321			break;
322			if( ( t = http_header( conn->http, "location:" ) ) == NULL )
323			return( 0 );
324	appaji-guest	4	sscanf( t, "%255s", s );
325	appaji-guest	2	if( strstr( s, "://" ) == NULL)
326			{
327			sprintf( conn->http->headers, "%s%s",
328			conn_url( conn ), s );
329			strncpy( s, conn->http->headers, MAX_STRING );
330			}
331			else if( s[0] == '/' )
332			{
333			sprintf( conn->http->headers, "http://%s:%i%s",
334			conn->host, conn->port, s );
335			strncpy( s, conn->http->headers, MAX_STRING );
336			}
337			conn_set( conn, s );
338			i ++;
339			}
340			while( conn->http->status / 100 == 3 && i < MAX_REDIR );
341
342			if( i == MAX_REDIR )
343			{
344			sprintf( conn->message, _("Too many redirects.\n") );
345			return( 0 );
346			}
347
348			conn->size = http_size( conn->http );
349			if( conn->http->status == 206 && conn->size >= 0 )
350			{
351			conn->supported = 1;
352			conn->size ++;
353			}
354			else if( conn->http->status == 200 \|\| conn->http->status == 206 )
355			{
356			conn->supported = 0;
357			conn->size = INT_MAX;
358			}
359			else
360			{
361			t = strchr( conn->message, '\n' );
362			if( t == NULL )
363			sprintf( conn->message, _("Unknown HTTP error.\n") );
364			else
365			*t = 0;
366			return( 0 );
367			}
368			}
369
370			return( 1 );
371			}