Mercurial > gftp.yaz
annotate lib/rfc959.c @ 114:fe36ed90aedd
2003-2-23 Brian Masney <masneyb@gftp.org>
* lib/cache.c - added function gftp_parse_cache_entry(). Save
request->server_type (output of SYST in FTP command) to the directory
entry
* lib/rfc959.c (rfc959_syst) - fix to parse the output correctly
* src/{text,gtk}/Makefile.am - remove @LIBINTL@. The gettext.m4
macro should automatically add this to the LIBS variable
author | masneyb |
---|---|
date | Mon, 24 Feb 2003 02:47:58 +0000 |
parents | 982e3890e7fe |
children | 76e2b58a9440 |
rev | line source |
---|---|
1 | 1 /*****************************************************************************/ |
2 /* rfc959.c - General purpose routines for the FTP protocol (RFC 959) */ | |
3 /* Copyright (C) 1998-2002 Brian Masney <masneyb@gftp.org> */ | |
4 /* */ | |
5 /* This program is free software; you can redistribute it and/or modify */ | |
6 /* it under the terms of the GNU General Public License as published by */ | |
7 /* the Free Software Foundation; either version 2 of the License, or */ | |
8 /* (at your option) any later version. */ | |
9 /* */ | |
10 /* This program is distributed in the hope that it will be useful, */ | |
11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ | |
12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ | |
13 /* GNU General Public License for more details. */ | |
14 /* */ | |
15 /* You should have received a copy of the GNU General Public License */ | |
16 /* along with this program; if not, write to the Free Software */ | |
17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA */ | |
18 /*****************************************************************************/ | |
19 | |
20 #include "gftp.h" | |
33 | 21 static const char cvsid[] = "$Id$"; |
1 | 22 |
58 | 23 typedef struct rfc959_params_tag |
24 { | |
25 gftp_getline_buffer * sockfd_rbuf, | |
26 * datafd_rbuf; | |
27 } rfc959_parms; | |
28 | |
29 | |
48 | 30 static int |
31 rfc959_read_response (gftp_request * request) | |
32 { | |
33 char tempstr[255], code[4]; | |
58 | 34 rfc959_parms * parms; |
35 ssize_t num_read; | |
48 | 36 |
84 | 37 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
38 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
39 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
48 | 40 |
41 *code = '\0'; | |
42 if (request->last_ftp_response) | |
43 { | |
44 g_free (request->last_ftp_response); | |
45 request->last_ftp_response = NULL; | |
46 } | |
47 | |
58 | 48 parms = request->protocol_data; |
49 | |
48 | 50 do |
51 { | |
58 | 52 if ((num_read = gftp_get_line (request, &parms->sockfd_rbuf, tempstr, |
60 | 53 sizeof (tempstr), request->sockfd)) <= 0) |
48 | 54 break; |
58 | 55 |
48 | 56 if (isdigit ((int) *tempstr) && isdigit ((int) *(tempstr + 1)) |
57 && isdigit ((int) *(tempstr + 2))) | |
58 { | |
59 strncpy (code, tempstr, 3); | |
60 code[3] = ' '; | |
61 } | |
62 request->logging_function (gftp_logging_recv, request->user_data, | |
63 "%s\n", tempstr); | |
64 } | |
65 while (strncmp (code, tempstr, 4) != 0); | |
66 | |
58 | 67 if (num_read < 0) |
84 | 68 return ((int) num_read); |
48 | 69 |
105 | 70 request->last_ftp_response = g_strdup (tempstr); |
48 | 71 |
72 if (request->last_ftp_response[0] == '4' && | |
73 request->last_ftp_response[1] == '2') | |
74 gftp_disconnect (request); | |
75 | |
76 return (*request->last_ftp_response); | |
77 } | |
78 | |
79 | |
80 static int | |
81 rfc959_send_command (gftp_request * request, const char *command) | |
82 { | |
84 | 83 int ret; |
84 | |
85 g_return_val_if_fail (request != NULL, GFTP_EFATAL); | |
86 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
87 g_return_val_if_fail (command != NULL, GFTP_EFATAL); | |
88 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
48 | 89 |
90 if (strncmp (command, "PASS", 4) == 0) | |
91 { | |
92 request->logging_function (gftp_logging_send, request->user_data, | |
93 "PASS xxxx\n"); | |
94 } | |
95 else if (strncmp (command, "ACCT", 4) == 0) | |
96 { | |
97 request->logging_function (gftp_logging_send, request->user_data, | |
98 "ACCT xxxx\n"); | |
99 } | |
100 else | |
101 { | |
102 request->logging_function (gftp_logging_send, request->user_data, "%s", | |
103 command); | |
104 } | |
105 | |
84 | 106 if ((ret = gftp_write (request, command, strlen (command), |
107 request->sockfd)) < 0) | |
108 return (ret); | |
48 | 109 |
110 return (rfc959_read_response (request)); | |
111 } | |
112 | |
113 | |
114 static char * | |
115 parse_ftp_proxy_string (gftp_request * request) | |
116 { | |
117 char *startpos, *endpos, *oldstr, *newstr, *newval, *tempport; | |
118 | |
119 g_return_val_if_fail (request != NULL, NULL); | |
120 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, NULL); | |
1 | 121 |
48 | 122 newstr = g_malloc (1); |
123 *newstr = '\0'; | |
124 startpos = endpos = request->proxy_config; | |
125 while (*endpos != '\0') | |
126 { | |
127 tempport = NULL; | |
128 if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'p') | |
129 { | |
130 switch (tolower ((int) *(endpos + 2))) | |
131 { | |
132 case 'u': | |
133 newval = request->proxy_username; | |
134 break; | |
135 case 'p': | |
136 newval = request->proxy_password; | |
137 break; | |
138 case 'h': | |
139 newval = request->proxy_hostname; | |
140 break; | |
141 case 'o': | |
142 tempport = g_strdup_printf ("%d", request->proxy_port); | |
143 newval = tempport; | |
144 break; | |
145 case 'a': | |
146 newval = request->proxy_account; | |
147 break; | |
148 default: | |
149 endpos++; | |
150 continue; | |
151 } | |
152 } | |
153 else if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'h') | |
154 { | |
155 switch (tolower ((int) *(endpos + 2))) | |
156 { | |
157 case 'u': | |
158 newval = request->username; | |
159 break; | |
160 case 'p': | |
161 newval = request->password; | |
162 break; | |
163 case 'h': | |
164 newval = request->hostname; | |
165 break; | |
166 case 'o': | |
167 tempport = g_strdup_printf ("%d", request->port); | |
168 newval = tempport; | |
169 break; | |
170 case 'a': | |
171 newval = request->account; | |
172 break; | |
173 default: | |
174 endpos++; | |
175 continue; | |
176 } | |
177 } | |
178 else if (*endpos == '%' && tolower ((int) *(endpos + 1)) == 'n') | |
179 { | |
180 *endpos = '\0'; | |
181 oldstr = newstr; | |
182 newstr = g_strconcat (oldstr, startpos, "\r\n", NULL); | |
183 g_free (oldstr); | |
184 endpos += 2; | |
185 startpos = endpos; | |
186 continue; | |
187 } | |
188 else | |
189 { | |
190 endpos++; | |
191 continue; | |
192 } | |
1 | 193 |
48 | 194 *endpos = '\0'; |
195 oldstr = newstr; | |
196 if (!newval) | |
197 newstr = g_strconcat (oldstr, startpos, NULL); | |
198 else | |
199 newstr = g_strconcat (oldstr, startpos, newval, NULL); | |
200 if (tempport) | |
201 { | |
202 g_free (tempport); | |
203 tempport = NULL; | |
204 } | |
205 g_free (oldstr); | |
206 endpos += 3; | |
207 startpos = endpos; | |
208 } | |
209 return (newstr); | |
210 } | |
211 | |
212 | |
213 static int | |
58 | 214 rfc959_getcwd (gftp_request * request) |
215 { | |
216 char *pos, *dir; | |
217 int ret; | |
218 | |
219 ret = rfc959_send_command (request, "PWD\r\n"); | |
220 if (ret < 0) | |
84 | 221 return (ret); |
58 | 222 else if (ret != '2') |
223 { | |
224 request->logging_function (gftp_logging_error, request->user_data, | |
225 _("Received invalid response to PWD command: '%s'\n"), | |
226 request->last_ftp_response); | |
227 gftp_disconnect (request); | |
84 | 228 return (GFTP_ERETRYABLE); |
58 | 229 } |
230 | |
231 if ((pos = strchr (request->last_ftp_response, '"')) == NULL) | |
232 { | |
233 request->logging_function (gftp_logging_error, request->user_data, | |
234 _("Received invalid response to PWD command: '%s'\n"), | |
235 request->last_ftp_response); | |
236 gftp_disconnect (request); | |
84 | 237 return (GFTP_EFATAL); |
58 | 238 } |
239 | |
240 dir = pos + 1; | |
241 | |
242 if ((pos = strchr (dir, '"')) == NULL) | |
243 { | |
244 request->logging_function (gftp_logging_error, request->user_data, | |
245 _("Received invalid response to PWD command: '%s'\n"), | |
246 request->last_ftp_response); | |
247 gftp_disconnect (request); | |
84 | 248 return (GFTP_EFATAL); |
58 | 249 } |
250 | |
251 *pos = '\0'; | |
252 | |
253 if (request->directory) | |
254 g_free (request->directory); | |
255 | |
105 | 256 request->directory = g_strdup (dir); |
58 | 257 return (0); |
258 } | |
259 | |
260 | |
261 static int | |
48 | 262 rfc959_chdir (gftp_request * request, const char *directory) |
263 { | |
58 | 264 char ret, *tempstr; |
84 | 265 int r; |
48 | 266 |
84 | 267 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
268 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
269 g_return_val_if_fail (directory != NULL, GFTP_EFATAL); | |
48 | 270 |
271 if (strcmp (directory, "..") == 0) | |
272 ret = rfc959_send_command (request, "CDUP\r\n"); | |
273 else | |
274 { | |
275 tempstr = g_strconcat ("CWD ", directory, "\r\n", NULL); | |
276 ret = rfc959_send_command (request, tempstr); | |
277 g_free (tempstr); | |
278 } | |
279 | |
280 if (ret != '2') | |
84 | 281 return (GFTP_ERETRYABLE); |
48 | 282 |
283 if (directory != request->directory) | |
284 { | |
84 | 285 if ((r = rfc959_getcwd (request)) < 0) |
286 return (r); | |
48 | 287 } |
288 | |
289 return (0); | |
1 | 290 } |
291 | |
292 | |
293 static int | |
91 | 294 rfc959_syst (gftp_request * request) |
295 { | |
296 char *stpos, *endpos; | |
297 int ret; | |
298 | |
299 g_return_val_if_fail (request != NULL, GFTP_EFATAL); | |
300 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
301 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
302 | |
303 ret = rfc959_send_command (request, "SYST\r\n"); | |
304 | |
305 if (ret < 0) | |
306 return (ret); | |
307 else if (ret != '2') | |
308 return (GFTP_ERETRYABLE); | |
309 | |
310 if ((stpos = strchr (request->last_ftp_response, ' ')) == NULL) | |
311 return (GFTP_ERETRYABLE); | |
312 | |
114 | 313 stpos++; |
314 | |
91 | 315 if ((endpos = strchr (stpos, ' ')) == NULL) |
316 return (GFTP_ERETRYABLE); | |
317 | |
318 *endpos = '\0'; | |
319 if (strcmp (stpos, "UNIX") == 0) | |
320 request->server_type = GFTP_TYPE_UNIX; | |
107 | 321 else if (strcmp (stpos, "VMS") == 0) |
322 request->server_type = GFTP_TYPE_VMS; | |
91 | 323 else |
324 request->server_type = GFTP_TYPE_OTHER; | |
325 | |
326 return (0); | |
327 } | |
328 | |
329 | |
330 static int | |
1 | 331 rfc959_connect (gftp_request * request) |
332 { | |
58 | 333 char tempchar, *startpos, *endpos, *tempstr; |
334 int ret, resp; | |
1 | 335 |
84 | 336 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
337 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
338 g_return_val_if_fail (request->hostname != NULL, GFTP_EFATAL); | |
1 | 339 |
58 | 340 if (request->sockfd > 0) |
341 return (0); | |
342 | |
7 | 343 if (request->username == NULL || *request->username == '\0') |
344 { | |
345 gftp_set_username (request, "anonymous"); | |
346 gftp_set_password (request, emailaddr); | |
347 } | |
348 else if (strcasecmp (request->username, "anonymous") == 0) | |
349 gftp_set_password (request, emailaddr); | |
350 | |
58 | 351 if ((request->sockfd = gftp_connect_server (request, "ftp")) < 0) |
84 | 352 return (request->sockfd); |
1 | 353 |
354 /* Get the banner */ | |
84 | 355 if ((ret = rfc959_read_response (request)) != '2') |
1 | 356 { |
357 gftp_disconnect (request); | |
84 | 358 return (ret); |
1 | 359 } |
360 | |
361 /* Login the proxy server if available */ | |
362 if (request->use_proxy) | |
363 { | |
364 resp = '3'; | |
365 startpos = endpos = tempstr = parse_ftp_proxy_string (request); | |
366 while ((resp == '3' || resp == '2') && *startpos != '\0') | |
367 { | |
368 if (*endpos == '\n' || *endpos == '\0') | |
369 { | |
370 tempchar = *(endpos + 1); | |
371 if (*endpos != '\0') | |
372 *(endpos + 1) = '\0'; | |
373 if ((resp = rfc959_send_command (request, startpos)) < 0) | |
84 | 374 return (resp); |
1 | 375 if (*endpos != '\0') |
376 *(endpos + 1) = tempchar; | |
377 else | |
378 break; | |
379 startpos = endpos + 1; | |
380 } | |
381 endpos++; | |
382 } | |
383 g_free (tempstr); | |
384 } | |
385 else | |
386 { | |
387 tempstr = g_strconcat ("USER ", request->username, "\r\n", NULL); | |
388 resp = rfc959_send_command (request, tempstr); | |
389 g_free (tempstr); | |
390 if (resp < 0) | |
84 | 391 return (GFTP_ERETRYABLE); |
1 | 392 if (resp == '3') |
393 { | |
394 tempstr = g_strconcat ("PASS ", request->password, "\r\n", NULL); | |
395 resp = rfc959_send_command (request, tempstr); | |
396 g_free (tempstr); | |
397 if (resp < 0) | |
84 | 398 return (GFTP_ERETRYABLE); |
1 | 399 } |
400 if (resp == '3' && request->account) | |
401 { | |
402 tempstr = g_strconcat ("ACCT ", request->account, "\r\n", NULL); | |
403 resp = rfc959_send_command (request, tempstr); | |
404 g_free (tempstr); | |
405 if (resp < 0) | |
84 | 406 return (GFTP_ERETRYABLE); |
1 | 407 } |
408 } | |
409 | |
410 if (resp != '2') | |
411 { | |
412 gftp_disconnect (request); | |
84 | 413 return (GFTP_EFATAL); |
1 | 414 } |
415 | |
91 | 416 if ((ret = rfc959_syst (request)) < 0 && request->sockfd < 0) |
417 return (ret); | |
418 | |
1 | 419 if (request->data_type == GFTP_TYPE_BINARY) |
420 tempstr = "TYPE I\r\n"; | |
421 else | |
422 tempstr = "TYPE A\r\n"; | |
423 | |
84 | 424 if ((ret = rfc959_send_command (request, tempstr)) < 0) |
425 return (ret); | |
1 | 426 |
427 ret = -1; | |
428 if (request->directory != NULL && *request->directory != '\0') | |
429 { | |
430 ret = rfc959_chdir (request, request->directory); | |
58 | 431 if (request->sockfd < 0) |
84 | 432 return (ret); |
1 | 433 } |
434 | |
435 if (ret != 0) | |
436 { | |
84 | 437 if ((ret = rfc959_getcwd (request)) < 0) |
438 return (ret); | |
1 | 439 } |
440 | |
58 | 441 if (request->sockfd < 0) |
84 | 442 return (GFTP_EFATAL); |
1 | 443 |
444 return (0); | |
445 } | |
446 | |
447 | |
448 static void | |
449 rfc959_disconnect (gftp_request * request) | |
450 { | |
451 g_return_if_fail (request != NULL); | |
452 g_return_if_fail (request->protonum == GFTP_FTP_NUM); | |
453 | |
58 | 454 if (request->sockfd > 0) |
1 | 455 { |
456 request->logging_function (gftp_logging_misc, request->user_data, | |
457 _("Disconnecting from site %s\n"), | |
458 request->hostname); | |
58 | 459 close (request->sockfd); |
460 request->sockfd = -1; | |
461 if (request->datafd > 0) | |
1 | 462 { |
58 | 463 close (request->datafd); |
464 request->datafd = -1; | |
1 | 465 } |
466 } | |
467 } | |
468 | |
469 | |
48 | 470 static int |
471 rfc959_data_connection_new (gftp_request * request) | |
472 { | |
473 char *pos, *pos1, resp, *command; | |
474 struct sockaddr_in data_addr; | |
475 size_t data_addr_len; | |
476 unsigned int temp[6]; | |
477 unsigned char ad[6]; | |
58 | 478 int i; |
48 | 479 |
84 | 480 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
481 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
482 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
48 | 483 |
58 | 484 if ((request->datafd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) |
48 | 485 { |
486 request->logging_function (gftp_logging_error, request->user_data, | |
487 _("Failed to create a socket: %s\n"), | |
488 g_strerror (errno)); | |
489 gftp_disconnect (request); | |
84 | 490 return (GFTP_ERETRYABLE); |
48 | 491 } |
492 | |
493 data_addr_len = sizeof (data_addr); | |
494 memset (&data_addr, 0, data_addr_len); | |
495 data_addr.sin_family = AF_INET; | |
496 | |
497 if (request->transfer_type == gftp_transfer_passive) | |
498 { | |
499 if ((resp = rfc959_send_command (request, "PASV\r\n")) != '2') | |
500 { | |
58 | 501 if (request->sockfd < 0) |
84 | 502 return (resp); |
48 | 503 |
504 request->transfer_type = gftp_transfer_active; | |
505 return (rfc959_data_connection_new (request)); | |
506 } | |
58 | 507 |
48 | 508 pos = request->last_ftp_response + 4; |
509 while (!isdigit ((int) *pos) && *pos != '\0') | |
510 pos++; | |
58 | 511 |
48 | 512 if (*pos == '\0') |
513 { | |
58 | 514 request->logging_function (gftp_logging_error, request->user_data, |
515 _("Cannot find an IP address in PASV response '%s'\n"), | |
516 request->last_ftp_response); | |
48 | 517 gftp_disconnect (request); |
84 | 518 return (GFTP_EFATAL); |
48 | 519 } |
58 | 520 |
48 | 521 if (sscanf (pos, "%u,%u,%u,%u,%u,%u", &temp[0], &temp[1], &temp[2], |
522 &temp[3], &temp[4], &temp[5]) != 6) | |
523 { | |
58 | 524 request->logging_function (gftp_logging_error, request->user_data, |
525 _("Cannot find an IP address in PASV response '%s'\n"), | |
526 request->last_ftp_response); | |
48 | 527 gftp_disconnect (request); |
84 | 528 return (GFTP_EFATAL); |
48 | 529 } |
58 | 530 |
48 | 531 for (i = 0; i < 6; i++) |
532 ad[i] = (unsigned char) (temp[i] & 0xff); | |
533 | |
534 memcpy (&data_addr.sin_addr, &ad[0], 4); | |
535 memcpy (&data_addr.sin_port, &ad[4], 2); | |
58 | 536 if (connect (request->datafd, (struct sockaddr *) &data_addr, |
537 data_addr_len) == -1) | |
48 | 538 { |
539 request->logging_function (gftp_logging_error, request->user_data, | |
540 _("Cannot create a data connection: %s\n"), | |
541 g_strerror (errno)); | |
542 gftp_disconnect (request); | |
84 | 543 return (GFTP_ERETRYABLE); |
48 | 544 } |
545 } | |
546 else | |
547 { | |
58 | 548 if (getsockname (request->sockfd, (struct sockaddr *) &data_addr, |
549 &data_addr_len) == -1) | |
550 { | |
551 request->logging_function (gftp_logging_error, request->user_data, | |
552 _("Cannot get socket name: %s\n"), | |
553 g_strerror (errno)); | |
554 gftp_disconnect (request); | |
84 | 555 return (GFTP_ERETRYABLE); |
58 | 556 } |
557 | |
48 | 558 data_addr.sin_port = 0; |
58 | 559 if (bind (request->datafd, (struct sockaddr *) &data_addr, |
560 data_addr_len) == -1) | |
48 | 561 { |
562 request->logging_function (gftp_logging_error, request->user_data, | |
563 _("Cannot bind a port: %s\n"), | |
564 g_strerror (errno)); | |
565 gftp_disconnect (request); | |
84 | 566 return (GFTP_ERETRYABLE); |
48 | 567 } |
568 | |
58 | 569 if (getsockname (request->datafd, (struct sockaddr *) &data_addr, |
570 &data_addr_len) == -1) | |
571 { | |
572 request->logging_function (gftp_logging_error, request->user_data, | |
573 _("Cannot get socket name: %s\n"), | |
574 g_strerror (errno)); | |
575 gftp_disconnect (request); | |
84 | 576 return (GFTP_ERETRYABLE); |
58 | 577 } |
578 | |
579 if (listen (request->datafd, 1) == -1) | |
48 | 580 { |
581 request->logging_function (gftp_logging_error, request->user_data, | |
582 _("Cannot listen on port %d: %s\n"), | |
583 ntohs (data_addr.sin_port), | |
584 g_strerror (errno)); | |
585 gftp_disconnect (request); | |
84 | 586 return (GFTP_ERETRYABLE); |
48 | 587 } |
58 | 588 |
48 | 589 pos = (char *) &data_addr.sin_addr; |
590 pos1 = (char *) &data_addr.sin_port; | |
591 command = g_strdup_printf ("PORT %u,%u,%u,%u,%u,%u\r\n", | |
592 pos[0] & 0xff, pos[1] & 0xff, pos[2] & 0xff, | |
593 pos[3] & 0xff, pos1[0] & 0xff, | |
594 pos1[1] & 0xff); | |
595 resp = rfc959_send_command (request, command); | |
596 g_free (command); | |
597 if (resp != '2') | |
598 { | |
599 gftp_disconnect (request); | |
84 | 600 return (GFTP_ERETRYABLE); |
48 | 601 } |
602 } | |
603 | |
604 return (0); | |
605 } | |
606 | |
607 | |
608 static int | |
609 rfc959_accept_active_connection (gftp_request * request) | |
610 { | |
611 struct sockaddr_in cli_addr; | |
612 size_t cli_addr_len; | |
84 | 613 int infd, ret; |
48 | 614 |
84 | 615 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
616 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
617 g_return_val_if_fail (request->datafd > 0, GFTP_EFATAL); | |
618 g_return_val_if_fail (request->transfer_type == gftp_transfer_active, GFTP_EFATAL); | |
48 | 619 |
620 cli_addr_len = sizeof (cli_addr); | |
58 | 621 |
84 | 622 if ((ret = gftp_set_sockblocking (request, request->datafd, 0)) < 0) |
623 return (ret); | |
58 | 624 |
625 if ((infd = accept (request->datafd, (struct sockaddr *) &cli_addr, | |
48 | 626 &cli_addr_len)) == -1) |
627 { | |
628 request->logging_function (gftp_logging_error, request->user_data, | |
629 _("Cannot accept connection from server: %s\n"), | |
630 g_strerror (errno)); | |
631 gftp_disconnect (request); | |
84 | 632 return (GFTP_ERETRYABLE); |
48 | 633 } |
634 | |
58 | 635 close (request->datafd); |
48 | 636 |
58 | 637 request->datafd = infd; |
84 | 638 if ((ret = gftp_set_sockblocking (request, request->datafd, 1)) < 0) |
639 return (ret); | |
58 | 640 |
48 | 641 return (0); |
642 } | |
643 | |
644 | |
58 | 645 static off_t |
646 rfc959_get_file (gftp_request * request, const char *filename, int fd, | |
1 | 647 off_t startsize) |
648 { | |
649 char *command, *tempstr, resp; | |
58 | 650 int ret; |
1 | 651 |
84 | 652 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
653 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
654 g_return_val_if_fail (filename != NULL, GFTP_EFATAL); | |
655 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 656 |
58 | 657 if (fd > 0) |
1 | 658 request->datafd = fd; |
659 | |
58 | 660 if (request->datafd < 0 && |
1 | 661 (ret = rfc959_data_connection_new (request)) < 0) |
662 return (ret); | |
663 | |
84 | 664 if ((ret = gftp_set_sockblocking (request, request->datafd, 1)) < 0) |
665 return (ret); | |
1 | 666 |
667 if (startsize > 0) | |
668 { | |
14
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
669 #if defined (_LARGEFILE_SOURCE) |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
670 command = g_strdup_printf ("REST %lld\r\n", startsize); |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
671 #else |
1 | 672 command = g_strdup_printf ("REST %ld\r\n", startsize); |
14
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
673 #endif |
1 | 674 resp = rfc959_send_command (request, command); |
675 g_free (command); | |
676 | |
677 if (resp != '3') | |
678 { | |
58 | 679 close (request->datafd); |
680 request->datafd = -1; | |
84 | 681 return (GFTP_ERETRYABLE); |
1 | 682 } |
683 } | |
684 | |
685 tempstr = g_strconcat ("RETR ", filename, "\r\n", NULL); | |
686 ret = rfc959_send_command (request, tempstr); | |
687 g_free (tempstr); | |
688 | |
689 if (ret != '1') | |
58 | 690 { |
691 close (request->datafd); | |
692 request->datafd = -1; | |
84 | 693 return (GFTP_ERETRYABLE); |
58 | 694 } |
1 | 695 |
696 if (request->transfer_type == gftp_transfer_active && | |
697 (ret = rfc959_accept_active_connection (request)) < 0) | |
698 return (ret); | |
699 | |
700 if ((tempstr = strrchr (request->last_ftp_response, '(')) == NULL) | |
701 { | |
702 tempstr = request->last_ftp_response + 4; | |
703 while (!isdigit ((int) *tempstr) && *tempstr != '\0') | |
704 tempstr++; | |
705 } | |
706 else | |
707 tempstr++; | |
708 | |
709 return (strtol (tempstr, NULL, 10) + startsize); | |
710 } | |
711 | |
712 | |
713 static int | |
58 | 714 rfc959_put_file (gftp_request * request, const char *filename, int fd, |
1 | 715 off_t startsize, off_t totalsize) |
716 { | |
717 char *command, *tempstr, resp; | |
58 | 718 int ret; |
1 | 719 |
84 | 720 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
721 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
722 g_return_val_if_fail (filename != NULL, GFTP_EFATAL); | |
723 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 724 |
58 | 725 if (fd > 0) |
1 | 726 fd = request->datafd; |
727 | |
58 | 728 if (request->datafd < 0 && |
1 | 729 (ret = rfc959_data_connection_new (request)) < 0) |
730 return (ret); | |
731 | |
84 | 732 if ((ret = gftp_set_sockblocking (request, request->datafd, 1)) < 0) |
733 return (ret); | |
1 | 734 |
735 if (startsize > 0) | |
736 { | |
14
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
737 #if defined (_LARGEFILE_SOURCE) |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
738 command = g_strdup_printf ("REST %lld\r\n", startsize); |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
739 #else |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
740 command = g_strdup_printf ("REST %ld\r\n", startsize); |
83090328581e
* More largefile support. Hopefully all that is left is the configure stuff
masneyb
parents:
7
diff
changeset
|
741 #endif |
1 | 742 resp = rfc959_send_command (request, command); |
743 g_free (command); | |
744 if (resp != '3') | |
745 { | |
58 | 746 close (request->datafd); |
747 request->datafd = -1; | |
84 | 748 return (GFTP_ERETRYABLE); |
1 | 749 } |
750 } | |
751 | |
752 tempstr = g_strconcat ("STOR ", filename, "\r\n", NULL); | |
753 ret = rfc959_send_command (request, tempstr); | |
754 g_free (tempstr); | |
755 if (ret != '1') | |
58 | 756 { |
757 close (request->datafd); | |
758 request->datafd = -1; | |
84 | 759 return (GFTP_ERETRYABLE); |
58 | 760 } |
1 | 761 |
762 if (request->transfer_type == gftp_transfer_active && | |
763 (ret = rfc959_accept_active_connection (request)) < 0) | |
764 return (ret); | |
765 | |
766 return (0); | |
767 } | |
768 | |
58 | 769 |
1 | 770 static long |
771 rfc959_transfer_file (gftp_request *fromreq, const char *fromfile, | |
772 off_t fromsize, gftp_request *toreq, | |
773 const char *tofile, off_t tosize) | |
774 { | |
775 char *tempstr, *pos, *endpos; | |
84 | 776 int ret; |
1 | 777 |
84 | 778 g_return_val_if_fail (fromreq != NULL, GFTP_EFATAL); |
779 g_return_val_if_fail (fromfile != NULL, GFTP_EFATAL); | |
780 g_return_val_if_fail (toreq != NULL, GFTP_EFATAL); | |
781 g_return_val_if_fail (tofile != NULL, GFTP_EFATAL); | |
782 g_return_val_if_fail (fromreq->sockfd > 0, GFTP_EFATAL); | |
783 g_return_val_if_fail (toreq->sockfd > 0, GFTP_EFATAL); | |
1 | 784 |
785 fromreq->transfer_type = gftp_transfer_passive; | |
786 toreq->transfer_type = gftp_transfer_active; | |
787 | |
84 | 788 if ((ret = rfc959_send_command (fromreq, "PASV\r\n")) != '2') |
789 return (ret); | |
1 | 790 |
791 pos = fromreq->last_ftp_response + 4; | |
792 while (!isdigit ((int) *pos) && *pos != '\0') | |
793 pos++; | |
794 if (*pos == '\0') | |
84 | 795 return (GFTP_EFATAL); |
1 | 796 |
797 endpos = pos; | |
798 while (*endpos != ')' && *endpos != '\0') | |
799 endpos++; | |
800 if (*endpos == ')') | |
801 *endpos = '\0'; | |
802 | |
803 tempstr = g_strconcat ("PORT ", pos, "\r\n", NULL); | |
84 | 804 if ((ret = rfc959_send_command (toreq, tempstr)) != '2') |
15
82fabd6ef1c4
FXP fixes (from Tobias Gruetzmacher <tobias@portfolio16.de>)
masneyb
parents:
14
diff
changeset
|
805 { |
82fabd6ef1c4
FXP fixes (from Tobias Gruetzmacher <tobias@portfolio16.de>)
masneyb
parents:
14
diff
changeset
|
806 g_free (tempstr); |
84 | 807 return (ret); |
15
82fabd6ef1c4
FXP fixes (from Tobias Gruetzmacher <tobias@portfolio16.de>)
masneyb
parents:
14
diff
changeset
|
808 } |
1 | 809 g_free (tempstr); |
810 | |
811 tempstr = g_strconcat ("RETR ", fromfile, "\r\n", NULL); | |
84 | 812 if ((ret = gftp_write (fromreq, tempstr, strlen (tempstr), |
813 fromreq->sockfd)) < 0) | |
58 | 814 { |
815 g_free (tempstr); | |
84 | 816 return (ret); |
58 | 817 } |
1 | 818 g_free (tempstr); |
819 | |
820 tempstr = g_strconcat ("STOR ", tofile, "\r\n", NULL); | |
84 | 821 if ((ret = gftp_write (toreq, tempstr, strlen (tempstr), toreq->sockfd)) < 0) |
58 | 822 { |
823 g_free (tempstr); | |
84 | 824 return (ret); |
58 | 825 } |
1 | 826 g_free (tempstr); |
827 | |
84 | 828 if ((ret = rfc959_read_response (fromreq)) < 0) |
829 return (ret); | |
830 | |
831 if ((ret = rfc959_read_response (toreq)) < 0) | |
832 return (ret); | |
1 | 833 |
834 return (0); | |
835 } | |
836 | |
837 | |
838 static int | |
839 rfc959_end_transfer (gftp_request * request) | |
840 { | |
84 | 841 int ret; |
842 | |
843 g_return_val_if_fail (request != NULL, GFTP_EFATAL); | |
844 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
845 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 846 |
58 | 847 if (request->datafd > 0) |
1 | 848 { |
58 | 849 close (request->datafd); |
850 request->datafd = -1; | |
1 | 851 } |
84 | 852 |
853 ret = rfc959_read_response (request); | |
854 | |
855 if (ret < 0) | |
856 return (ret); | |
857 else if (ret == '2') | |
858 return (0); | |
859 else | |
860 return (GFTP_ERETRYABLE); | |
1 | 861 } |
862 | |
863 | |
864 static int | |
40 | 865 rfc959_abort_transfer (gftp_request * request) |
866 { | |
867 int ret; | |
868 | |
84 | 869 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
870 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
871 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
40 | 872 |
58 | 873 if (request->datafd > 0) |
40 | 874 { |
58 | 875 close (request->datafd); |
876 request->datafd = -1; | |
40 | 877 } |
878 | |
879 /* We need to read two lines of output. The first one is acknowleging | |
880 the transfer and the second line acknowleges the ABOR command */ | |
84 | 881 if ((ret = rfc959_send_command (request, "ABOR\r\n")) < 0) |
882 return (ret); | |
40 | 883 |
58 | 884 if (request->sockfd > 0) |
40 | 885 { |
58 | 886 if ((ret = rfc959_read_response (request)) < 0) |
40 | 887 gftp_disconnect (request); |
888 } | |
889 | |
890 return (0); | |
891 } | |
892 | |
893 | |
894 static int | |
1 | 895 rfc959_list_files (gftp_request * request) |
896 { | |
897 char *tempstr, parms[3]; | |
898 int ret; | |
899 | |
84 | 900 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
901 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
902 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 903 |
904 if ((ret = rfc959_data_connection_new (request)) < 0) | |
905 return (ret); | |
906 | |
907 *parms = '\0'; | |
908 strcat (parms, show_hidden_files ? "a" : ""); | |
909 strcat (parms, resolve_symlinks ? "L" : ""); | |
910 tempstr = g_strconcat ("LIST", *parms != '\0' ? " -" : "", parms, "\r\n", | |
911 NULL); | |
912 | |
913 ret = rfc959_send_command (request, tempstr); | |
914 g_free (tempstr); | |
915 | |
916 if (ret != '1') | |
84 | 917 return (GFTP_ERETRYABLE); |
1 | 918 |
919 ret = 0; | |
920 if (request->transfer_type == gftp_transfer_active) | |
921 ret = rfc959_accept_active_connection (request); | |
922 | |
923 return (ret); | |
924 } | |
925 | |
926 | |
927 int | |
58 | 928 rfc959_get_next_file (gftp_request * request, gftp_file * fle, int fd) |
1 | 929 { |
58 | 930 rfc959_parms * parms; |
1 | 931 char tempstr[255]; |
58 | 932 ssize_t len; |
1 | 933 |
84 | 934 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
935 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
936 g_return_val_if_fail (fle != NULL, GFTP_EFATAL); | |
937 g_return_val_if_fail (fd > 0, GFTP_EFATAL); | |
1 | 938 |
939 if (request->last_dir_entry) | |
940 { | |
941 g_free (request->last_dir_entry); | |
942 request->last_dir_entry = NULL; | |
943 } | |
58 | 944 |
945 parms = request->protocol_data; | |
946 | |
1 | 947 do |
948 { | |
58 | 949 if ((len = gftp_get_line (request, &parms->datafd_rbuf, |
60 | 950 tempstr, sizeof (tempstr), fd)) <= 0) |
1 | 951 { |
952 gftp_file_destroy (fle); | |
58 | 953 return ((int) len); |
1 | 954 } |
955 | |
91 | 956 if (gftp_parse_ls (request, tempstr, fle) != 0) |
1 | 957 { |
58 | 958 if (strncmp (tempstr, "total", strlen ("total")) != 0 && |
959 strncmp (tempstr, _("total"), strlen (_("total"))) != 0) | |
960 request->logging_function (gftp_logging_error, request->user_data, | |
1 | 961 _("Warning: Cannot parse listing %s\n"), |
962 tempstr); | |
963 gftp_file_destroy (fle); | |
964 continue; | |
965 } | |
966 else | |
967 break; | |
968 } | |
969 while (1); | |
970 | |
971 len = strlen (tempstr); | |
972 if (!request->cached) | |
973 { | |
60 | 974 request->last_dir_entry = g_strdup_printf ("%s\n", tempstr); |
975 request->last_dir_entry_len = len + 1; | |
1 | 976 } |
977 return (len); | |
978 } | |
979 | |
980 | |
981 static int | |
982 rfc959_set_data_type (gftp_request * request, int data_type) | |
983 { | |
984 char *tempstr; | |
84 | 985 int ret; |
1 | 986 |
84 | 987 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
988 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1 | 989 |
58 | 990 if (request->sockfd > 0 && request->data_type != data_type) |
1 | 991 { |
992 if (data_type == GFTP_TYPE_BINARY) | |
993 tempstr = "TYPE I\r\n"; | |
994 else | |
995 tempstr = "TYPE A\r\n"; | |
996 | |
84 | 997 if ((ret = rfc959_send_command (request, tempstr)) != '2') |
998 return (ret); | |
1 | 999 } |
1000 request->data_type = data_type; | |
1001 return (0); | |
1002 } | |
1003 | |
1004 | |
1005 static off_t | |
1006 rfc959_get_file_size (gftp_request * request, const char *filename) | |
1007 { | |
1008 char *tempstr; | |
1009 int ret; | |
1010 | |
1011 g_return_val_if_fail (request != NULL, 0); | |
84 | 1012 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); |
1 | 1013 g_return_val_if_fail (filename != NULL, 0); |
58 | 1014 g_return_val_if_fail (request->sockfd > 0, 0); |
1 | 1015 |
1016 tempstr = g_strconcat ("SIZE ", filename, "\r\n", NULL); | |
1017 ret = rfc959_send_command (request, tempstr); | |
1018 g_free (tempstr); | |
1019 if (ret < 0) | |
84 | 1020 return (ret); |
1 | 1021 |
1022 if (*request->last_ftp_response != '2') | |
1023 return (0); | |
1024 return (strtol (request->last_ftp_response + 4, NULL, 10)); | |
1025 } | |
1026 | |
1027 | |
1028 static int | |
1029 rfc959_rmdir (gftp_request * request, const char *directory) | |
1030 { | |
1031 char *tempstr, ret; | |
1032 | |
84 | 1033 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1034 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1035 g_return_val_if_fail (directory != NULL, GFTP_EFATAL); | |
1036 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1037 |
1038 tempstr = g_strconcat ("RMD ", directory, "\r\n", NULL); | |
1039 ret = rfc959_send_command (request, tempstr); | |
1040 g_free (tempstr); | |
84 | 1041 |
1042 if (ret < 0) | |
1043 return (ret); | |
1044 else if (ret == '2') | |
1045 return (0); | |
1046 else | |
1047 return (GFTP_ERETRYABLE); | |
1 | 1048 } |
1049 | |
1050 | |
1051 static int | |
1052 rfc959_rmfile (gftp_request * request, const char *file) | |
1053 { | |
1054 char *tempstr, ret; | |
1055 | |
84 | 1056 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1057 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1058 g_return_val_if_fail (file != NULL, GFTP_EFATAL); | |
1059 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1060 |
1061 tempstr = g_strconcat ("DELE ", file, "\r\n", NULL); | |
1062 ret = rfc959_send_command (request, tempstr); | |
1063 g_free (tempstr); | |
84 | 1064 |
1065 if (ret < 0) | |
1066 return (ret); | |
1067 else if (ret == '2') | |
1068 return (0); | |
1069 else | |
1070 return (GFTP_ERETRYABLE); | |
1 | 1071 } |
1072 | |
1073 | |
1074 static int | |
1075 rfc959_mkdir (gftp_request * request, const char *directory) | |
1076 { | |
1077 char *tempstr, ret; | |
1078 | |
84 | 1079 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1080 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1081 g_return_val_if_fail (directory != NULL, GFTP_EFATAL); | |
1082 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1083 |
1084 tempstr = g_strconcat ("MKD ", directory, "\r\n", NULL); | |
1085 ret = rfc959_send_command (request, tempstr); | |
1086 g_free (tempstr); | |
84 | 1087 |
1088 if (ret < 0) | |
1089 return (ret); | |
1090 else if (ret == '2') | |
1091 return (0); | |
1092 else | |
1093 return (GFTP_ERETRYABLE); | |
1 | 1094 } |
1095 | |
1096 | |
1097 static int | |
1098 rfc959_rename (gftp_request * request, const char *oldname, | |
1099 const char *newname) | |
1100 { | |
1101 char *tempstr, ret; | |
1102 | |
84 | 1103 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1104 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1105 g_return_val_if_fail (oldname != NULL, GFTP_EFATAL); | |
1106 g_return_val_if_fail (newname != NULL, GFTP_EFATAL); | |
1107 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1108 |
1109 tempstr = g_strconcat ("RNFR ", oldname, "\r\n", NULL); | |
1110 ret = rfc959_send_command (request, tempstr); | |
1111 g_free (tempstr); | |
84 | 1112 |
1113 if (ret < 0) | |
1114 return (ret); | |
1115 else if (ret != '2') | |
1116 return (GFTP_ERETRYABLE); | |
1 | 1117 |
1118 tempstr = g_strconcat ("RNTO ", newname, "\r\n", NULL); | |
1119 ret = rfc959_send_command (request, tempstr); | |
1120 g_free (tempstr); | |
84 | 1121 |
1122 if (ret < 0) | |
1123 return (ret); | |
1124 else if (ret == '2') | |
1125 return (0); | |
1126 else | |
1127 return (GFTP_ERETRYABLE); | |
1 | 1128 } |
1129 | |
1130 | |
1131 static int | |
1132 rfc959_chmod (gftp_request * request, const char *file, int mode) | |
1133 { | |
1134 char *tempstr, ret; | |
1135 | |
84 | 1136 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1137 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1138 g_return_val_if_fail (file != NULL, GFTP_EFATAL); | |
1139 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1140 |
1141 tempstr = g_malloc (strlen (file) + (mode / 10) + 16); | |
1142 sprintf (tempstr, "SITE CHMOD %d %s\r\n", mode, file); | |
1143 ret = rfc959_send_command (request, tempstr); | |
1144 g_free (tempstr); | |
84 | 1145 |
1146 if (ret < 0) | |
1147 return (ret); | |
1148 else if (ret == '2') | |
1149 return (0); | |
1150 else | |
1151 return (GFTP_ERETRYABLE); | |
1 | 1152 } |
1153 | |
1154 | |
1155 static int | |
1156 rfc959_site (gftp_request * request, const char *command) | |
1157 { | |
1158 char *tempstr, ret; | |
1159 | |
84 | 1160 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1161 g_return_val_if_fail (request->protonum == GFTP_FTP_NUM, GFTP_EFATAL); | |
1162 g_return_val_if_fail (command != NULL, GFTP_EFATAL); | |
1163 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); | |
1 | 1164 |
1165 tempstr = g_strconcat ("SITE ", command, "\r\n", NULL); | |
1166 ret = rfc959_send_command (request, tempstr); | |
1167 g_free (tempstr); | |
84 | 1168 |
1169 if (ret < 0) | |
1170 return (ret); | |
1171 else if (ret == '2') | |
1172 return (0); | |
1173 else | |
1174 return (GFTP_ERETRYABLE); | |
58 | 1175 } |
1176 | |
1177 | |
1178 static void | |
1179 rfc959_set_config_options (gftp_request * request) | |
1180 { | |
1181 request->transfer_type = passive_transfer ? gftp_transfer_passive : gftp_transfer_active; | |
1182 | |
1183 if (strcmp (proxy_config, "http") != 0) | |
1184 { | |
1185 gftp_set_proxy_hostname (request, firewall_host); | |
1186 gftp_set_proxy_port (request, firewall_port); | |
1187 gftp_set_proxy_username (request, firewall_username); | |
1188 gftp_set_proxy_password (request, firewall_password); | |
1189 gftp_set_proxy_account (request, firewall_account); | |
1190 gftp_set_proxy_config (request, proxy_config); | |
1191 } | |
1192 else | |
1193 { | |
1194 gftp_set_proxy_hostname (request, http_proxy_host); | |
1195 gftp_set_proxy_port (request, http_proxy_port); | |
1196 gftp_set_proxy_username (request, http_proxy_username); | |
1197 gftp_set_proxy_password (request, http_proxy_password); | |
1198 | |
1199 | |
1200 if (request->proxy_config == NULL) | |
1201 { | |
1202 gftp_protocols[GFTP_HTTP_NUM].init (request); | |
1203 request->proxy_config = g_strdup ("ftp"); | |
1204 } | |
1205 } | |
1 | 1206 } |
1207 | |
1208 | |
48 | 1209 void |
1210 rfc959_init (gftp_request * request) | |
1 | 1211 { |
48 | 1212 g_return_if_fail (request != NULL); |
1 | 1213 |
48 | 1214 request->protonum = GFTP_FTP_NUM; |
1215 request->init = rfc959_init; | |
1216 request->destroy = NULL; | |
1217 request->connect = rfc959_connect; | |
1218 request->disconnect = rfc959_disconnect; | |
1219 request->get_file = rfc959_get_file; | |
1220 request->put_file = rfc959_put_file; | |
1221 request->transfer_file = rfc959_transfer_file; | |
1222 request->get_next_file_chunk = NULL; | |
1223 request->put_next_file_chunk = NULL; | |
1224 request->end_transfer = rfc959_end_transfer; | |
1225 request->abort_transfer = rfc959_abort_transfer; | |
1226 request->list_files = rfc959_list_files; | |
1227 request->get_next_file = rfc959_get_next_file; | |
1228 request->set_data_type = rfc959_set_data_type; | |
1229 request->get_file_size = rfc959_get_file_size; | |
1230 request->chdir = rfc959_chdir; | |
1231 request->rmdir = rfc959_rmdir; | |
1232 request->rmfile = rfc959_rmfile; | |
1233 request->mkdir = rfc959_mkdir; | |
1234 request->rename = rfc959_rename; | |
1235 request->chmod = rfc959_chmod; | |
1236 request->set_file_time = NULL; | |
1237 request->site = rfc959_site; | |
1238 request->parse_url = NULL; | |
63 | 1239 request->swap_socks = NULL; |
58 | 1240 request->set_config_options = rfc959_set_config_options; |
48 | 1241 request->url_prefix = "ftp"; |
1242 request->protocol_name = "FTP"; | |
1243 request->need_hostport = 1; | |
1244 request->need_userpass = 1; | |
1245 request->use_cache = 1; | |
1246 request->use_threads = 1; | |
1247 request->always_connected = 0; | |
58 | 1248 request->protocol_data = g_malloc0 (sizeof (rfc959_parms)); |
48 | 1249 gftp_set_config_options (request); |
1 | 1250 } |
1251 |