1
|
1 /*****************************************************************************/
|
|
2 /* sshv2.c - functions that will use the sshv2 protocol */
|
122
|
3 /* Copyright (C) 1998-2003 Brian Masney <masneyb@gftp.org> */
|
1
|
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
|
|
23 #define SSH_MAX_HANDLE_SIZE 256
|
|
24 #define SSH_MAX_STRING_SIZE 34000
|
|
25
|
122
|
26 static gftp_config_vars config_vars[] =
|
|
27 {
|
227
|
28 {"", N_("SSH"), gftp_option_type_notebook, NULL, NULL,
|
|
29 GFTP_CVARS_FLAGS_SHOW_BOOKMARK, NULL, GFTP_PORT_GTK, NULL},
|
122
|
30
|
|
31 {"ssh_prog_name", N_("SSH Prog Name:"),
|
|
32 gftp_option_type_text, "ssh", NULL, 0,
|
|
33 N_("The path to the SSH executable"), GFTP_PORT_ALL, NULL},
|
|
34 {"ssh_extra_params", N_("SSH Extra Params:"),
|
124
|
35 gftp_option_type_text, NULL, NULL, 0,
|
122
|
36 N_("Extra parameters to pass to the SSH program"), GFTP_PORT_ALL, NULL},
|
|
37
|
|
38 {"ssh_need_userpass", N_("Need SSH User/Pass"),
|
227
|
39 gftp_option_type_checkbox, GINT_TO_POINTER(1), NULL,
|
|
40 GFTP_CVARS_FLAGS_SHOW_BOOKMARK,
|
122
|
41 N_("Require a username/password for SSH connections"), GFTP_PORT_ALL, NULL},
|
227
|
42
|
122
|
43 {NULL, NULL, 0, NULL, NULL, 0, NULL, 0, NULL}
|
|
44 };
|
|
45
|
|
46
|
1
|
47 typedef struct sshv2_message_tag
|
|
48 {
|
516
|
49 guint32 length;
|
1
|
50 char command;
|
|
51 char *buffer,
|
|
52 *pos,
|
|
53 *end;
|
|
54 } sshv2_message;
|
|
55
|
|
56 typedef struct sshv2_params_tag
|
|
57 {
|
296
|
58 char handle[SSH_MAX_HANDLE_SIZE + 4], /* We'll encode the ID in here too */
|
538
|
59 *transfer_buffer;
|
|
60 size_t handle_len, transfer_buffer_len;
|
296
|
61
|
525
|
62 guint32 id,
|
|
63 count;
|
1
|
64 sshv2_message message;
|
|
65
|
296
|
66 unsigned int initialized : 1,
|
|
67 dont_log_status : 1; /* For uploading files */
|
|
68
|
1
|
69 #ifdef G_HAVE_GINT64
|
525
|
70 guint64 offset;
|
1
|
71 #else
|
525
|
72 guint32 offset;
|
1
|
73 #endif
|
|
74 } sshv2_params;
|
|
75
|
|
76
|
|
77 #define SSH_MY_VERSION 3
|
|
78
|
|
79 #define SSH_FXP_INIT 1
|
|
80 #define SSH_FXP_VERSION 2
|
|
81 #define SSH_FXP_OPEN 3
|
|
82 #define SSH_FXP_CLOSE 4
|
|
83 #define SSH_FXP_READ 5
|
|
84 #define SSH_FXP_WRITE 6
|
|
85 #define SSH_FXP_LSTAT 7
|
|
86 #define SSH_FXP_FSTAT 8
|
|
87 #define SSH_FXP_SETSTAT 9
|
|
88 #define SSH_FXP_FSETSTAT 10
|
|
89 #define SSH_FXP_OPENDIR 11
|
|
90 #define SSH_FXP_READDIR 12
|
|
91 #define SSH_FXP_REMOVE 13
|
|
92 #define SSH_FXP_MKDIR 14
|
|
93 #define SSH_FXP_RMDIR 15
|
|
94 #define SSH_FXP_REALPATH 16
|
|
95 #define SSH_FXP_STAT 17
|
|
96 #define SSH_FXP_RENAME 18
|
498
|
97 #define SSH_FXP_READLINK 19
|
|
98 #define SSH_FXP_SYMLINK 20
|
|
99
|
1
|
100 #define SSH_FXP_STATUS 101
|
|
101 #define SSH_FXP_HANDLE 102
|
|
102 #define SSH_FXP_DATA 103
|
|
103 #define SSH_FXP_NAME 104
|
|
104 #define SSH_FXP_ATTRS 105
|
|
105 #define SSH_FXP_EXTENDED 200
|
|
106 #define SSH_FXP_EXTENDED_REPLY 201
|
|
107
|
|
108 #define SSH_FILEXFER_ATTR_SIZE 0x00000001
|
|
109 #define SSH_FILEXFER_ATTR_UIDGID 0x00000002
|
|
110 #define SSH_FILEXFER_ATTR_PERMISSIONS 0x00000004
|
|
111 #define SSH_FILEXFER_ATTR_ACMODTIME 0x00000008
|
|
112 #define SSH_FILEXFER_ATTR_EXTENDED 0x80000000
|
|
113
|
498
|
114 #define SSH_FILEXFER_TYPE_REGULAR 1
|
|
115 #define SSH_FILEXFER_TYPE_DIRECTORY 2
|
|
116 #define SSH_FILEXFER_TYPE_SYMLINK 3
|
|
117 #define SSH_FILEXFER_TYPE_SPECIAL 4
|
|
118 #define SSH_FILEXFER_TYPE_UNKNOWN 5
|
|
119
|
1
|
120 #define SSH_FXF_READ 0x00000001
|
|
121 #define SSH_FXF_WRITE 0x00000002
|
|
122 #define SSH_FXF_APPEND 0x00000004
|
|
123 #define SSH_FXF_CREAT 0x00000008
|
|
124 #define SSH_FXF_TRUNC 0x00000010
|
|
125 #define SSH_FXF_EXCL 0x00000020
|
|
126
|
|
127 #define SSH_FX_OK 0
|
|
128 #define SSH_FX_EOF 1
|
|
129 #define SSH_FX_NO_SUCH_FILE 2
|
|
130 #define SSH_FX_PERMISSION_DENIED 3
|
|
131 #define SSH_FX_FAILURE 4
|
|
132 #define SSH_FX_BAD_MESSAGE 5
|
|
133 #define SSH_FX_NO_CONNECTION 6
|
|
134 #define SSH_FX_CONNECTION_LOST 7
|
|
135 #define SSH_FX_OP_UNSUPPORTED 8
|
|
136
|
122
|
137 #define SSH_LOGIN_BUFSIZE 200
|
|
138 #define SSH_ERROR_BADPASS -1
|
|
139 #define SSH_ERROR_QUESTION -2
|
|
140
|
493
|
141
|
487
|
142 static char *
|
840
|
143 sshv2_initialize_buffer (gftp_request * request, size_t len)
|
487
|
144 {
|
|
145 sshv2_params * params;
|
516
|
146 guint32 num;
|
487
|
147 char *ret;
|
|
148
|
|
149 params = request->protocol_data;
|
765
|
150 ret = g_malloc0 ((gulong) len + 1);
|
487
|
151
|
|
152 num = htonl (params->id++);
|
|
153 memcpy (ret, &num, 4);
|
|
154
|
|
155 return (ret);
|
|
156 }
|
|
157
|
|
158
|
|
159 static void
|
839
|
160 sshv2_add_string_to_buf (char *buf, const char *str, size_t len)
|
487
|
161 {
|
516
|
162 guint32 num;
|
487
|
163
|
|
164 num = htonl (strlen (str));
|
|
165 memcpy (buf, &num, 4);
|
839
|
166 memcpy (buf + 4, str, len);
|
487
|
167 }
|
|
168
|
|
169
|
|
170 static char *
|
840
|
171 sshv2_initialize_buffer_with_i18n_string (gftp_request * request,
|
|
172 const char *str, size_t *msglen)
|
|
173 {
|
|
174 const char *addstr;
|
|
175 char *utf8, *ret;
|
|
176 size_t pathlen;
|
|
177
|
845
|
178 utf8 = gftp_filename_from_utf8 (request, str, &pathlen);
|
840
|
179 if (utf8 != NULL)
|
|
180 addstr = utf8;
|
|
181 else
|
|
182 {
|
|
183 addstr = str;
|
|
184 pathlen = strlen (str);
|
|
185 }
|
|
186
|
849
|
187 *msglen += pathlen + 8;
|
840
|
188 ret = sshv2_initialize_buffer (request, *msglen);
|
|
189 sshv2_add_string_to_buf (ret + 4, addstr, pathlen);
|
|
190
|
|
191 if (utf8 != NULL)
|
|
192 g_free (utf8);
|
|
193
|
|
194 return (ret);
|
|
195 }
|
|
196
|
|
197
|
|
198 static char *
|
|
199 _sshv2_generate_utf8_path (gftp_request * request, const char *str, size_t *len)
|
|
200 {
|
|
201 char *path, *ret, *utf8;
|
|
202
|
|
203 if (*str == '/')
|
|
204 path = g_strdup (str);
|
|
205 else
|
|
206 path = gftp_build_path (request, request->directory, str, NULL);
|
|
207
|
845
|
208 utf8 = gftp_filename_from_utf8 (request, path, len);
|
840
|
209 if (utf8 != NULL)
|
|
210 {
|
|
211 g_free (path);
|
|
212 return (utf8);
|
|
213 }
|
|
214 else
|
|
215 {
|
|
216 *len = strlen (path);
|
|
217 return (path);
|
|
218 }
|
|
219 }
|
|
220
|
|
221
|
|
222 static char *
|
|
223 sshv2_initialize_buffer_with_two_i18n_paths (gftp_request * request,
|
|
224 const char *str1,
|
|
225 const char *str2, size_t *msglen)
|
|
226 {
|
|
227 char *first_utf8, *sec_utf8, *ret;
|
|
228 size_t pathlen1, pathlen2;
|
|
229
|
|
230 first_utf8 = _sshv2_generate_utf8_path (request, str1, &pathlen1);
|
|
231 sec_utf8 = _sshv2_generate_utf8_path (request, str2, &pathlen2);
|
|
232
|
849
|
233 *msglen += pathlen1 + pathlen2 + 12;
|
840
|
234 ret = sshv2_initialize_buffer (request, *msglen);
|
|
235 sshv2_add_string_to_buf (ret + 4, first_utf8, pathlen1);
|
|
236 sshv2_add_string_to_buf (ret + 8 + pathlen1, sec_utf8, pathlen2);
|
|
237
|
|
238 if (first_utf8 != str1)
|
|
239 g_free (first_utf8);
|
|
240
|
|
241 if (sec_utf8 != str2)
|
|
242 g_free (sec_utf8);
|
|
243
|
|
244 return (ret);
|
|
245 }
|
|
246
|
849
|
247
|
840
|
248 static char *
|
489
|
249 sshv2_initialize_string_with_path (gftp_request * request, const char *path,
|
|
250 size_t *len, char **endpos)
|
487
|
251 {
|
|
252 char *ret, *tempstr;
|
849
|
253 size_t origlen;
|
487
|
254
|
849
|
255 origlen = *len;
|
487
|
256 if (*path == '/')
|
840
|
257 ret = sshv2_initialize_buffer_with_i18n_string (request, path, len);
|
487
|
258 else
|
|
259 {
|
555
|
260 tempstr = gftp_build_path (request, request->directory, path, NULL);
|
840
|
261 ret = sshv2_initialize_buffer_with_i18n_string (request, tempstr, len);
|
487
|
262 g_free (tempstr);
|
|
263 }
|
|
264
|
489
|
265 if (endpos != NULL)
|
849
|
266 *endpos = ret + *len - origlen;
|
489
|
267
|
487
|
268 return (ret);
|
|
269 }
|
|
270
|
|
271
|
124
|
272 static void
|
|
273 sshv2_add_exec_args (char **logstr, size_t *logstr_len, char ***args,
|
487
|
274 size_t *args_len, size_t *args_max, char *first, ...)
|
124
|
275 {
|
|
276 char tempstr[2048], *curpos, *endpos, save_char;
|
|
277 va_list argp;
|
|
278 int at_end;
|
|
279
|
|
280 va_start (argp, first);
|
|
281 g_vsnprintf (tempstr, sizeof (tempstr), first, argp);
|
|
282 va_end (argp);
|
|
283
|
|
284 *logstr_len += strlen (tempstr);
|
765
|
285 *logstr = g_realloc (*logstr, (gulong) *logstr_len + 1);
|
124
|
286 strcat (*logstr, tempstr);
|
|
287
|
|
288 curpos = tempstr;
|
|
289 while (*curpos == ' ')
|
|
290 curpos++;
|
|
291
|
|
292 save_char = ' ';
|
|
293 at_end = 0;
|
|
294 while (!at_end)
|
|
295 {
|
|
296 if (*curpos == '"')
|
|
297 {
|
|
298 curpos++;
|
|
299 endpos = strchr (curpos + 1, '"');
|
|
300 }
|
|
301 else
|
|
302 endpos = strchr (curpos, ' ');
|
|
303
|
|
304 if (endpos == NULL)
|
|
305 at_end = 1;
|
|
306 else
|
|
307 {
|
|
308 save_char = *endpos;
|
|
309 *endpos = '\0';
|
|
310 }
|
|
311
|
487
|
312 if (*args_max == *args_len + 1)
|
124
|
313 {
|
487
|
314 *args_max += 10;
|
|
315 *args = g_realloc (*args, sizeof (char *) * *args_max);
|
124
|
316 }
|
|
317
|
|
318 (*args)[(*args_len)++] = g_strdup (curpos);
|
|
319 (*args)[*args_len] = NULL;
|
|
320
|
|
321 if (!at_end)
|
|
322 {
|
|
323 *endpos = save_char;
|
|
324 curpos = endpos + 1;
|
|
325 while (*curpos == ' ')
|
|
326 curpos++;
|
|
327 }
|
|
328 }
|
|
329 }
|
|
330
|
122
|
331
|
|
332 static char **
|
484
|
333 sshv2_gen_exec_args (gftp_request * request)
|
122
|
334 {
|
124
|
335 size_t logstr_len, args_len, args_cur;
|
|
336 char **args, *tempstr, *logstr;
|
122
|
337
|
124
|
338 gftp_lookup_request_option (request, "ssh_prog_name", &tempstr);
|
|
339 if (tempstr == NULL || *tempstr == '\0')
|
|
340 tempstr = "ssh";
|
122
|
341
|
124
|
342 args_len = 1;
|
|
343 args_cur = 15;
|
|
344 args = g_malloc (sizeof (char *) * args_cur);
|
|
345 args[0] = g_strdup (tempstr);
|
122
|
346
|
124
|
347 logstr = g_strdup (args[0]);
|
|
348 logstr_len = strlen (logstr);
|
122
|
349
|
124
|
350 gftp_lookup_request_option (request, "ssh_extra_params", &tempstr);
|
|
351 if (tempstr != NULL && *tempstr != '\0')
|
|
352 sshv2_add_exec_args (&logstr, &logstr_len, &args, &args_len, &args_cur,
|
|
353 "%s", tempstr);
|
122
|
354
|
124
|
355 sshv2_add_exec_args (&logstr, &logstr_len, &args, &args_len, &args_cur,
|
|
356 " -e none");
|
122
|
357
|
|
358 if (request->username && *request->username != '\0')
|
124
|
359 sshv2_add_exec_args (&logstr, &logstr_len, &args, &args_len, &args_cur,
|
|
360 " -l %s", request->username);
|
122
|
361
|
124
|
362 sshv2_add_exec_args (&logstr, &logstr_len, &args, &args_len, &args_cur,
|
|
363 " -p %d", request->port);
|
122
|
364
|
484
|
365 sshv2_add_exec_args (&logstr, &logstr_len, &args, &args_len, &args_cur,
|
|
366 " %s -s sftp", request->hostname);
|
122
|
367
|
186
|
368 request->logging_function (gftp_logging_misc, request,
|
124
|
369 _("Running program %s\n"), logstr);
|
|
370 g_free (logstr);
|
122
|
371 return (args);
|
|
372 }
|
|
373
|
|
374
|
458
|
375 static int
|
|
376 sshv2_start_login_sequence (gftp_request * request, int fdm, int ptymfd)
|
122
|
377 {
|
541
|
378 static char *pwstrs[] = {N_("Enter passphrase for RSA key"),
|
|
379 N_("Enter passphrase for key '"),
|
|
380 N_("Password"),
|
|
381 N_("password"),
|
|
382 NULL};
|
484
|
383 char *tempstr, *temp1str, *pwstr, *yesstr = "yes\n", *securid_pass;
|
541
|
384 int wrotepw, ok, maxfd, ret, clear_tempstr, pwidx;
|
484
|
385 size_t rem, len, diff;
|
458
|
386 fd_set rset, eset;
|
122
|
387 ssize_t rd;
|
|
388
|
|
389 rem = len = SSH_LOGIN_BUFSIZE;
|
484
|
390 diff = 0;
|
765
|
391 tempstr = g_malloc0 ((gulong) len + 1);
|
122
|
392 wrotepw = 0;
|
|
393 ok = 1;
|
|
394
|
458
|
395 if (gftp_fd_set_sockblocking (request, fdm, 1) == -1)
|
|
396 return (GFTP_ERETRYABLE);
|
|
397
|
|
398 if (gftp_fd_set_sockblocking (request, ptymfd, 1) == -1)
|
|
399 return (GFTP_ERETRYABLE);
|
122
|
400
|
458
|
401 if (request->password == NULL)
|
|
402 pwstr = g_strdup ("\n");
|
|
403 else
|
|
404 pwstr = g_strconcat (request->password, "\n", NULL);
|
|
405
|
|
406 FD_ZERO (&rset);
|
|
407 FD_ZERO (&eset);
|
|
408 maxfd = fdm > ptymfd ? fdm : ptymfd;
|
122
|
409
|
|
410 errno = 0;
|
|
411 while (1)
|
|
412 {
|
458
|
413 FD_SET (fdm, &rset);
|
|
414 FD_SET (ptymfd, &rset);
|
|
415
|
|
416 FD_SET (fdm, &eset);
|
|
417 FD_SET (ptymfd, &eset);
|
|
418
|
|
419 ret = select (maxfd + 1, &rset, NULL, &eset, NULL);
|
546
|
420 if (ret < 0 && (errno == EINTR || errno == EAGAIN))
|
458
|
421 continue;
|
|
422
|
|
423 if (ret < 0)
|
122
|
424 {
|
458
|
425 request->logging_function (gftp_logging_error, request,
|
|
426 _("Connection to %s timed out\n"),
|
|
427 request->hostname);
|
|
428 gftp_disconnect (request);
|
|
429 return (GFTP_ERETRYABLE);
|
|
430 }
|
|
431
|
|
432 if (FD_ISSET (fdm, &eset) || FD_ISSET (ptymfd, &eset))
|
|
433 {
|
|
434 request->logging_function (gftp_logging_error, request,
|
|
435 _("Error: Could not read from socket: %s\n"),
|
|
436 g_strerror (errno));
|
|
437 gftp_disconnect (request);
|
|
438 return (GFTP_ERETRYABLE);
|
|
439 }
|
|
440
|
|
441 if (FD_ISSET (fdm, &rset))
|
|
442 {
|
|
443 ok = 1;
|
122
|
444 break;
|
|
445 }
|
458
|
446 else if (!FD_ISSET (ptymfd, &rset))
|
|
447 continue;
|
|
448
|
|
449 rd = gftp_fd_read (request, tempstr + diff, rem - 1, ptymfd);
|
|
450 if (rd < 0)
|
|
451 return (rd);
|
|
452 else if (rd == 0)
|
|
453 continue;
|
|
454
|
484
|
455 tempstr[diff + rd] = '\0';
|
|
456 request->logging_function (gftp_logging_recv, request, "%s", tempstr + diff);
|
122
|
457 rem -= rd;
|
|
458 diff += rd;
|
|
459
|
541
|
460 /* See if we are at the enter password prompt... */
|
|
461 for (pwidx = 0; pwstrs[pwidx] != NULL; pwidx++)
|
|
462 {
|
|
463 if (strstr (tempstr, pwstrs[pwidx]) != NULL ||
|
|
464 strstr (tempstr, _(pwstrs[pwidx])) != NULL)
|
|
465 break;
|
|
466 }
|
|
467
|
765
|
468 clear_tempstr = 0;
|
541
|
469 if (pwstrs[pwidx] != NULL)
|
122
|
470 {
|
484
|
471 clear_tempstr = 1;
|
122
|
472 if (wrotepw)
|
|
473 {
|
|
474 ok = SSH_ERROR_BADPASS;
|
|
475 break;
|
|
476 }
|
|
477
|
|
478 wrotepw = 1;
|
458
|
479 if (gftp_fd_write (request, pwstr, strlen (pwstr), ptymfd) < 0)
|
122
|
480 {
|
|
481 ok = 0;
|
|
482 break;
|
|
483 }
|
|
484 }
|
541
|
485 else if (strstr (tempstr, "(yes/no)?") != NULL ||
|
|
486 strstr (tempstr, _("(yes/no)?")) != NULL)
|
122
|
487 {
|
484
|
488 clear_tempstr = 1;
|
460
|
489 if (!gftpui_protocol_ask_yes_no (request, request->hostname, tempstr))
|
|
490 {
|
|
491 ok = SSH_ERROR_QUESTION;
|
|
492 break;
|
|
493 }
|
|
494 else
|
|
495 {
|
|
496 if (gftp_fd_write (request, yesstr, strlen (yesstr), ptymfd) < 0)
|
|
497 {
|
|
498 ok = 0;
|
|
499 break;
|
|
500 }
|
|
501 }
|
122
|
502 }
|
541
|
503 else if (strstr (tempstr, "Enter PASSCODE:") != NULL ||
|
|
504 strstr (tempstr, _("Enter PASSCODE:")) != NULL)
|
484
|
505 {
|
|
506 clear_tempstr = 1;
|
|
507 securid_pass = gftpui_protocol_ask_user_input (request,
|
|
508 _("Enter Password"),
|
|
509 _("Enter SecurID Password:"), 0);
|
|
510
|
|
511 if (securid_pass == NULL || *securid_pass == '\0')
|
|
512 {
|
|
513 ok = SSH_ERROR_BADPASS;
|
|
514 break;
|
|
515 }
|
|
516
|
|
517 temp1str = g_strconcat (securid_pass, "\n", NULL);
|
|
518
|
487
|
519 ret = gftp_fd_write (request, temp1str, strlen (temp1str), ptymfd);
|
484
|
520
|
|
521 memset (temp1str, 0, strlen (temp1str));
|
|
522 g_free (temp1str);
|
|
523 memset (securid_pass, 0, strlen (securid_pass));
|
|
524 g_free (securid_pass);
|
|
525
|
|
526 if (ret <= 0)
|
|
527 {
|
|
528 ok = 0;
|
|
529 break;
|
|
530 }
|
|
531 }
|
122
|
532 else if (rem <= 1)
|
|
533 {
|
|
534 len += SSH_LOGIN_BUFSIZE;
|
|
535 rem += SSH_LOGIN_BUFSIZE;
|
|
536 tempstr = g_realloc (tempstr, len);
|
|
537 continue;
|
|
538 }
|
484
|
539
|
|
540 if (clear_tempstr)
|
|
541 {
|
|
542 *tempstr = '\0';
|
|
543 rem = SSH_LOGIN_BUFSIZE;
|
|
544 diff = 0;
|
|
545 }
|
122
|
546 }
|
|
547
|
|
548 g_free (pwstr);
|
458
|
549 g_free (tempstr);
|
|
550
|
122
|
551 if (ok <= 0)
|
|
552 {
|
484
|
553 request->logging_function (gftp_logging_error, request, "\n");
|
|
554
|
122
|
555 if (ok == SSH_ERROR_BADPASS)
|
186
|
556 request->logging_function (gftp_logging_error, request,
|
122
|
557 _("Error: An incorrect password was entered\n"));
|
|
558
|
460
|
559 gftp_disconnect (request);
|
458
|
560 return (GFTP_EFATAL);
|
122
|
561 }
|
|
562
|
458
|
563 return (0);
|
122
|
564 }
|
|
565
|
|
566
|
48
|
567 static void
|
|
568 sshv2_log_command (gftp_request * request, gftp_logging_level level,
|
|
569 char type, char *message, size_t length)
|
1
|
570 {
|
516
|
571 guint32 id, num, attr, stattype;
|
48
|
572 char *descr, *pos, oldchar;
|
1
|
573 sshv2_params * params;
|
|
574
|
48
|
575 params = request->protocol_data;
|
|
576 memcpy (&id, message, 4);
|
|
577 id = ntohl (id);
|
|
578 switch (type)
|
|
579 {
|
487
|
580 case SSH_FXP_DATA:
|
|
581 case SSH_FXP_READ:
|
|
582 case SSH_FXP_WRITE:
|
|
583 break;
|
48
|
584 case SSH_FXP_INIT:
|
186
|
585 request->logging_function (level, request,
|
48
|
586 _("%d: Protocol Initialization\n"), id);
|
|
587 break;
|
|
588 case SSH_FXP_VERSION:
|
186
|
589 request->logging_function (level, request,
|
487
|
590 _("%d: Protocol version %d\n"), id, id);
|
48
|
591 break;
|
|
592 case SSH_FXP_OPEN:
|
|
593 memcpy (&num, message + 4, 4);
|
|
594 num = ntohl (num);
|
|
595 pos = message + 12 + num - 1;
|
|
596 oldchar = *pos;
|
|
597 *pos = '\0';
|
186
|
598 request->logging_function (level, request,
|
48
|
599 _("%d: Open %s\n"), id, message + 8);
|
|
600 *pos = oldchar;
|
|
601 break;
|
|
602 case SSH_FXP_CLOSE:
|
186
|
603 request->logging_function (level, request,
|
48
|
604 _("%d: Close\n"), id);
|
765
|
605 break;
|
48
|
606 case SSH_FXP_OPENDIR:
|
186
|
607 request->logging_function (level, request,
|
48
|
608 _("%d: Open Directory %s\n"), id,
|
|
609 message + 8);
|
|
610 break;
|
|
611 case SSH_FXP_READDIR:
|
186
|
612 request->logging_function (level, request,
|
48
|
613 _("%d: Read Directory\n"), id);
|
|
614 break;
|
|
615 case SSH_FXP_REMOVE:
|
186
|
616 request->logging_function (level, request,
|
48
|
617 _("%d: Remove file %s\n"), id,
|
|
618 message + 8);
|
|
619 break;
|
|
620 case SSH_FXP_MKDIR:
|
186
|
621 request->logging_function (level, request,
|
48
|
622 _("%d: Make directory %s\n"), id,
|
|
623 message + 8);
|
|
624 break;
|
|
625 case SSH_FXP_RMDIR:
|
186
|
626 request->logging_function (level, request,
|
48
|
627 _("%d: Remove directory %s\n"), id,
|
|
628 message + 8);
|
|
629 break;
|
|
630 case SSH_FXP_REALPATH:
|
186
|
631 request->logging_function (level, request,
|
48
|
632 _("%d: Realpath %s\n"), id,
|
|
633 message + 8);
|
|
634 break;
|
|
635 case SSH_FXP_ATTRS:
|
186
|
636 request->logging_function (level, request,
|
48
|
637 _("%d: File attributes\n"), id);
|
|
638 break;
|
|
639 case SSH_FXP_STAT:
|
186
|
640 request->logging_function (level, request,
|
48
|
641 _("%d: Stat %s\n"), id,
|
|
642 message + 8);
|
|
643 break;
|
|
644 case SSH_FXP_SETSTAT:
|
|
645 memcpy (&num, message + 4, 4);
|
|
646 num = ntohl (num);
|
529
|
647
|
48
|
648 memcpy (&stattype, message + 8 + num, 4);
|
|
649 stattype = ntohl (stattype);
|
|
650 memcpy (&attr, message + 12 + num, 4);
|
|
651 attr = ntohl (attr);
|
529
|
652
|
|
653 pos = message + 8 + num;
|
|
654 oldchar = *pos;
|
|
655 *pos = '\0';
|
|
656
|
48
|
657 switch (stattype)
|
|
658 {
|
|
659 case SSH_FILEXFER_ATTR_PERMISSIONS:
|
186
|
660 request->logging_function (level, request,
|
48
|
661 _("%d: Chmod %s %o\n"), id,
|
|
662 message + 8, attr);
|
|
663 break;
|
|
664 case SSH_FILEXFER_ATTR_ACMODTIME:
|
186
|
665 request->logging_function (level, request,
|
48
|
666 _("%d: Utime %s %d\n"), id,
|
|
667 message + 8, attr);
|
|
668 }
|
529
|
669
|
48
|
670 *pos = oldchar;
|
|
671 break;
|
|
672 case SSH_FXP_STATUS:
|
|
673 if (params->dont_log_status)
|
|
674 break;
|
|
675 memcpy (&num, message + 4, 4);
|
|
676 num = ntohl (num);
|
|
677 switch (num)
|
|
678 {
|
|
679 case SSH_FX_OK:
|
|
680 descr = _("OK");
|
|
681 break;
|
|
682 case SSH_FX_EOF:
|
|
683 descr = _("EOF");
|
|
684 break;
|
|
685 case SSH_FX_NO_SUCH_FILE:
|
|
686 descr = _("No such file or directory");
|
|
687 break;
|
|
688 case SSH_FX_PERMISSION_DENIED:
|
|
689 descr = _("Permission denied");
|
|
690 break;
|
|
691 case SSH_FX_FAILURE:
|
|
692 descr = _("Failure");
|
|
693 break;
|
|
694 case SSH_FX_BAD_MESSAGE:
|
|
695 descr = _("Bad message");
|
|
696 break;
|
|
697 case SSH_FX_NO_CONNECTION:
|
|
698 descr = _("No connection");
|
|
699 break;
|
|
700 case SSH_FX_CONNECTION_LOST:
|
|
701 descr = _("Connection lost");
|
|
702 break;
|
|
703 case SSH_FX_OP_UNSUPPORTED:
|
|
704 descr = _("Operation unsupported");
|
|
705 break;
|
|
706 default:
|
|
707 descr = _("Unknown message returned from server");
|
|
708 break;
|
|
709 }
|
186
|
710 request->logging_function (level, request,
|
48
|
711 "%d: %s\n", id, descr);
|
|
712 break;
|
|
713 case SSH_FXP_HANDLE:
|
186
|
714 request->logging_function (level, request,
|
48
|
715 "%d: File handle\n", id);
|
|
716 break;
|
|
717 case SSH_FXP_NAME:
|
|
718 memcpy (&num, message + 4, 4);
|
|
719 num = ntohl (num);
|
186
|
720 request->logging_function (level, request,
|
48
|
721 "%d: Filenames (%d entries)\n", id,
|
|
722 num);
|
|
723 break;
|
|
724 default:
|
186
|
725 request->logging_function (level, request,
|
48
|
726 "Command: %x\n", type);
|
|
727 }
|
|
728 }
|
1
|
729
|
48
|
730
|
|
731 static int
|
|
732 sshv2_send_command (gftp_request * request, char type, char *command,
|
321
|
733 size_t len)
|
48
|
734 {
|
|
735 char buf[34000];
|
516
|
736 guint32 clen;
|
84
|
737 int ret;
|
48
|
738
|
|
739 if (len > 33995)
|
|
740 {
|
186
|
741 request->logging_function (gftp_logging_error, request,
|
48
|
742 _("Error: Message size %d too big\n"), len);
|
|
743 gftp_disconnect (request);
|
84
|
744 return (GFTP_EFATAL);
|
48
|
745 }
|
|
746
|
|
747 clen = htonl (len + 1);
|
|
748 memcpy (buf, &clen, 4);
|
|
749 buf[4] = type;
|
|
750 memcpy (&buf[5], command, len);
|
|
751 buf[len + 5] = '\0';
|
|
752
|
|
753 #ifdef DEBUG
|
458
|
754 printf ("\rSending to FD %d: ", request->datafd);
|
61
|
755 for (clen=0; clen<len + 5; clen++)
|
|
756 printf ("%x ", buf[clen] & 0xff);
|
48
|
757 printf ("\n");
|
|
758 #endif
|
|
759
|
|
760 sshv2_log_command (request, gftp_logging_send, type, buf + 5, len);
|
|
761
|
169
|
762 if ((ret = gftp_fd_write (request, buf, len + 5, request->datafd)) < 0)
|
84
|
763 return (ret);
|
48
|
764
|
84
|
765 return (0);
|
48
|
766 }
|
|
767
|
|
768
|
|
769 static int
|
|
770 sshv2_read_response (gftp_request * request, sshv2_message * message,
|
58
|
771 int fd)
|
48
|
772 {
|
219
|
773 char buf[6], error_buffer[255], *pos;
|
|
774 sshv2_params * params;
|
518
|
775 ssize_t numread;
|
|
776 size_t rem;
|
219
|
777
|
|
778 params = request->protocol_data;
|
48
|
779
|
58
|
780 if (fd <= 0)
|
169
|
781 fd = request->datafd;
|
1
|
782
|
61
|
783 pos = buf;
|
|
784 rem = 5;
|
|
785 while (rem > 0)
|
|
786 {
|
168
|
787 if ((numread = gftp_fd_read (request, pos, rem, fd)) < 0)
|
516
|
788 return (numread);
|
61
|
789 rem -= numread;
|
|
790 pos += numread;
|
|
791 }
|
219
|
792 buf[5] = '\0';
|
48
|
793
|
|
794 memcpy (&message->length, buf, 4);
|
|
795 message->length = ntohl (message->length);
|
|
796 if (message->length > 34000)
|
|
797 {
|
219
|
798 if (params->initialized)
|
|
799 {
|
|
800 request->logging_function (gftp_logging_error, request,
|
48
|
801 _("Error: Message size %d too big from server\n"),
|
|
802 message->length);
|
219
|
803 }
|
|
804 else
|
|
805 {
|
|
806 request->logging_function (gftp_logging_error, request,
|
|
807 _("There was an error initializing a SSH connection with the remote server. The error message from the remote server follows:\n"), buf);
|
|
808
|
|
809 request->logging_function (gftp_logging_error, request, "%s", buf);
|
|
810
|
243
|
811 if (gftp_fd_set_sockblocking (request, fd, 0) == -1)
|
|
812 return (GFTP_EFATAL);
|
|
813
|
|
814 if ((numread = gftp_fd_read (NULL, error_buffer,
|
219
|
815 sizeof (error_buffer) - 1,
|
|
816 fd)) > 0)
|
|
817 {
|
|
818 error_buffer[numread] = '\0';
|
|
819 request->logging_function (gftp_logging_error, request,
|
|
820 "%s", error_buffer);
|
|
821 }
|
|
822 }
|
|
823
|
48
|
824 memset (message, 0, sizeof (*message));
|
|
825 gftp_disconnect (request);
|
84
|
826 return (GFTP_EFATAL);
|
48
|
827 }
|
58
|
828
|
48
|
829 message->command = buf[4];
|
61
|
830 message->buffer = g_malloc (message->length + 1);
|
48
|
831
|
|
832 message->pos = message->buffer;
|
|
833 message->end = message->buffer + message->length - 1;
|
|
834
|
61
|
835 pos = message->buffer;
|
|
836 rem = message->length - 1;
|
|
837 while (rem > 0)
|
|
838 {
|
168
|
839 if ((numread = gftp_fd_read (request, pos, rem, fd)) < 0)
|
516
|
840 return (numread);
|
61
|
841 rem -= numread;
|
|
842 pos += numread;
|
|
843 }
|
48
|
844
|
654
|
845 #ifdef DEBUG
|
|
846 printf ("\rReceived message: ");
|
|
847 for (rem=0; rem<message->length; rem++)
|
|
848 printf ("%x ", message->buffer[rem] & 0xff);
|
|
849 printf ("\n");
|
|
850 #endif
|
|
851
|
61
|
852 message->buffer[message->length] = '\0';
|
48
|
853
|
|
854 sshv2_log_command (request, gftp_logging_recv, message->command,
|
|
855 message->buffer, message->length);
|
|
856
|
|
857 return (message->command);
|
1
|
858 }
|
|
859
|
|
860
|
|
861 static void
|
|
862 sshv2_destroy (gftp_request * request)
|
|
863 {
|
|
864 g_return_if_fail (request != NULL);
|
|
865 g_return_if_fail (request->protonum == GFTP_SSHV2_NUM);
|
|
866
|
|
867 g_free (request->protocol_data);
|
|
868 request->protocol_data = NULL;
|
|
869 }
|
|
870
|
|
871
|
48
|
872 static void
|
|
873 sshv2_message_free (sshv2_message * message)
|
|
874 {
|
|
875 if (message->buffer)
|
|
876 g_free (message->buffer);
|
|
877 memset (message, 0, sizeof (*message));
|
|
878 }
|
|
879
|
|
880
|
487
|
881 static int
|
493
|
882 sshv2_wrong_response (gftp_request * request, sshv2_message * message)
|
|
883 {
|
|
884 request->logging_function (gftp_logging_error, request,
|
|
885 _("Received wrong response from server, disconnecting\n"));
|
|
886 gftp_disconnect (request);
|
|
887
|
|
888 if (message != NULL)
|
|
889 sshv2_message_free (message);
|
|
890
|
|
891 return (GFTP_EFATAL);
|
|
892 }
|
|
893
|
|
894
|
|
895 static int
|
487
|
896 sshv2_read_status_response (gftp_request * request, sshv2_message * message,
|
|
897 int fd, int fxp_is_retryable, int fxp_is_wrong)
|
|
898 {
|
|
899 int ret;
|
|
900
|
|
901 memset (message, 0, sizeof (*message));
|
|
902 ret = sshv2_read_response (request, message, -1);
|
|
903 if (ret < 0)
|
|
904 return (ret);
|
|
905 else if (fxp_is_retryable > 0 && ret == fxp_is_retryable)
|
|
906 {
|
|
907 sshv2_message_free (message);
|
|
908 return (GFTP_ERETRYABLE);
|
|
909 }
|
|
910 else if (fxp_is_wrong > 0 && ret != fxp_is_wrong)
|
493
|
911 return (sshv2_wrong_response (request, message));
|
487
|
912
|
|
913 return (ret);
|
|
914 }
|
|
915
|
|
916
|
525
|
917 static int
|
654
|
918 sshv2_response_return_code (gftp_request * request, sshv2_message * message,
|
|
919 unsigned int ret)
|
|
920 {
|
|
921 switch (ret)
|
|
922 {
|
|
923 case SSH_FX_OK:
|
|
924 case SSH_FX_EOF:
|
|
925 case SSH_FX_NO_SUCH_FILE:
|
|
926 case SSH_FX_PERMISSION_DENIED:
|
|
927 case SSH_FX_FAILURE:
|
|
928 case SSH_FX_OP_UNSUPPORTED:
|
|
929 return (GFTP_ERETRYABLE);
|
|
930 default:
|
|
931 return (sshv2_wrong_response (request, message));
|
|
932 }
|
|
933 }
|
|
934
|
|
935
|
|
936 static int
|
48
|
937 sshv2_buffer_get_int32 (gftp_request * request, sshv2_message * message,
|
654
|
938 unsigned int expected_response, int check_response,
|
|
939 guint32 * num)
|
48
|
940 {
|
525
|
941 guint32 snum;
|
48
|
942
|
|
943 if (message->end - message->pos < 4)
|
493
|
944 return (sshv2_wrong_response (request, message));
|
525
|
945
|
|
946 memcpy (&snum, message->pos, 4);
|
|
947 snum = ntohl (snum);
|
48
|
948 message->pos += 4;
|
|
949
|
654
|
950 if (check_response && snum != expected_response)
|
|
951 return (sshv2_response_return_code (request, message, snum));
|
|
952
|
|
953 if (num != NULL)
|
|
954 *num = snum;
|
|
955
|
|
956 return (0);
|
|
957 }
|
|
958
|
|
959
|
|
960 static int
|
|
961 sshv2_buffer_get_int64 (gftp_request * request, sshv2_message * message,
|
|
962 unsigned int expected_response, int check_response,
|
|
963 #if G_HAVE_GINT64
|
|
964 guint64 * num)
|
|
965 {
|
|
966 guint64 snum;
|
|
967 #else
|
|
968 guint32 * num)
|
|
969 {
|
|
970 guint32 snum;
|
|
971 #endif
|
|
972 guint32 hinum, lonum;
|
|
973 int ret;
|
|
974
|
|
975 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &hinum)) < 0)
|
|
976 return (ret);
|
|
977
|
|
978 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &lonum)) < 0)
|
|
979 return (ret);
|
|
980
|
|
981 #if G_HAVE_GINT64
|
|
982 snum = (gint64) lonum | ((gint64) hinum >> 32);
|
|
983 #else
|
|
984 snum = lonum;
|
|
985 #endif
|
|
986
|
|
987 if (check_response && snum != expected_response)
|
|
988 return (sshv2_response_return_code (request, message, snum));
|
48
|
989
|
525
|
990 if (num != NULL)
|
|
991 *num = snum;
|
|
992
|
|
993 return (0);
|
48
|
994 }
|
|
995
|
|
996
|
|
997 static char *
|
654
|
998 sshv2_buffer_get_string (gftp_request * request, sshv2_message * message,
|
|
999 int return_string)
|
48
|
1000 {
|
654
|
1001 guint32 len, buflen;
|
48
|
1002 char *string;
|
|
1003
|
654
|
1004 if (sshv2_buffer_get_int32 (request, message, 0, 0, &len) < 0)
|
48
|
1005 return (NULL);
|
|
1006
|
654
|
1007 buflen = message->end - message->pos;
|
|
1008 if (len > SSH_MAX_STRING_SIZE || (buflen < len))
|
48
|
1009 {
|
493
|
1010 sshv2_wrong_response (request, message);
|
48
|
1011 return (NULL);
|
|
1012 }
|
|
1013
|
654
|
1014 if (return_string)
|
|
1015 {
|
|
1016 string = g_malloc (len + 1);
|
|
1017 memcpy (string, message->pos, len);
|
|
1018 string[len] = '\0';
|
|
1019 }
|
|
1020 else
|
|
1021 string = NULL;
|
|
1022
|
48
|
1023 message->pos += len;
|
|
1024 return (string);
|
|
1025 }
|
|
1026
|
|
1027
|
|
1028 static int
|
|
1029 sshv2_getcwd (gftp_request * request)
|
|
1030 {
|
843
|
1031 char *tempstr, *dir, *utf8;
|
48
|
1032 sshv2_message message;
|
843
|
1033 size_t len;
|
64
|
1034 int ret;
|
48
|
1035
|
84
|
1036 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1037 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
48
|
1038
|
|
1039 if (request->directory == NULL || *request->directory == '\0')
|
|
1040 dir = ".";
|
|
1041 else
|
|
1042 dir = request->directory;
|
|
1043
|
849
|
1044 len = 0;
|
843
|
1045 tempstr = sshv2_initialize_buffer_with_i18n_string (request, dir, &len);
|
|
1046 ret = sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, len);
|
48
|
1047 g_free (tempstr);
|
487
|
1048 if (ret < 0)
|
|
1049 return (ret);
|
|
1050
|
48
|
1051 if (request->directory)
|
|
1052 {
|
|
1053 g_free (request->directory);
|
|
1054 request->directory = NULL;
|
|
1055 }
|
|
1056
|
487
|
1057 ret = sshv2_read_status_response (request, &message, -1, SSH_FXP_STATUS,
|
|
1058 SSH_FXP_NAME);
|
84
|
1059 if (ret < 0)
|
|
1060 return (ret);
|
48
|
1061
|
|
1062 message.pos += 4;
|
654
|
1063 if ((ret = sshv2_buffer_get_int32 (request, &message, 1, 1, NULL)) < 0)
|
84
|
1064 return (ret);
|
48
|
1065
|
843
|
1066 if ((dir = sshv2_buffer_get_string (request, &message, 1)) == NULL)
|
84
|
1067 return (GFTP_EFATAL);
|
64
|
1068
|
845
|
1069 utf8 = gftp_filename_to_utf8 (request, dir, &len);
|
843
|
1070 if (utf8 != NULL)
|
|
1071 {
|
|
1072 request->directory = utf8;
|
|
1073 g_free (dir);
|
|
1074 }
|
|
1075 else
|
|
1076 request->directory = dir;
|
|
1077
|
48
|
1078 sshv2_message_free (&message);
|
|
1079 return (0);
|
|
1080 }
|
|
1081
|
|
1082
|
124
|
1083 static void
|
|
1084 sshv2_free_args (char **args)
|
|
1085 {
|
|
1086 int i;
|
|
1087
|
|
1088 for (i=0; args[i] != NULL; i++)
|
|
1089 g_free (args[i]);
|
|
1090 g_free (args);
|
|
1091 }
|
|
1092
|
|
1093
|
1
|
1094 static int
|
|
1095 sshv2_connect (gftp_request * request)
|
|
1096 {
|
124
|
1097 struct servent serv_struct;
|
219
|
1098 sshv2_params * params;
|
1
|
1099 sshv2_message message;
|
516
|
1100 int ret, fdm, ptymfd;
|
|
1101 guint32 version;
|
484
|
1102 char **args;
|
1
|
1103 pid_t child;
|
|
1104
|
84
|
1105 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1106 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1107 g_return_val_if_fail (request->hostname != NULL, GFTP_EFATAL);
|
1
|
1108
|
169
|
1109 if (request->datafd > 0)
|
1
|
1110 return (0);
|
|
1111
|
219
|
1112 params = request->protocol_data;
|
|
1113
|
186
|
1114 request->logging_function (gftp_logging_misc, request,
|
1
|
1115 _("Opening SSH connection to %s\n"),
|
|
1116 request->hostname);
|
|
1117
|
124
|
1118 if (request->port == 0)
|
|
1119 {
|
|
1120 if (!r_getservbyname ("ssh", "tcp", &serv_struct, NULL))
|
|
1121 {
|
186
|
1122 request->logging_function (gftp_logging_error, request,
|
124
|
1123 _("Cannot look up service name %s/tcp. Please check your services file\n"),
|
|
1124 "ssh");
|
|
1125 }
|
|
1126 else
|
|
1127 request->port = ntohs (serv_struct.s_port);
|
|
1128 }
|
|
1129
|
484
|
1130 args = sshv2_gen_exec_args (request);
|
1
|
1131
|
458
|
1132 child = gftp_exec (request, &fdm, &ptymfd, args);
|
210
|
1133
|
|
1134 if (child == 0)
|
|
1135 exit (0);
|
1
|
1136
|
210
|
1137 sshv2_free_args (args);
|
1
|
1138
|
458
|
1139 if (child < 0)
|
|
1140 return (GFTP_ERETRYABLE);
|
|
1141
|
210
|
1142 request->datafd = fdm;
|
84
|
1143
|
210
|
1144 version = htonl (SSH_MY_VERSION);
|
|
1145 if ((ret = sshv2_send_command (request, SSH_FXP_INIT, (char *)
|
|
1146 &version, 4)) < 0)
|
|
1147 return (ret);
|
1
|
1148
|
458
|
1149 ret = sshv2_start_login_sequence (request, fdm, ptymfd);
|
|
1150 if (ret < 0)
|
|
1151 return (ret);
|
|
1152
|
210
|
1153 memset (&message, 0, sizeof (message));
|
219
|
1154 ret = sshv2_read_response (request, &message, -1);
|
|
1155 if (ret < 0)
|
|
1156 {
|
|
1157 sshv2_message_free (&message);
|
|
1158 return (ret);
|
|
1159 }
|
|
1160 else if (ret != SSH_FXP_VERSION)
|
493
|
1161 return (sshv2_wrong_response (request, &message));
|
219
|
1162
|
210
|
1163 sshv2_message_free (&message);
|
|
1164
|
219
|
1165 params->initialized = 1;
|
210
|
1166 request->logging_function (gftp_logging_misc, request,
|
|
1167 _("Successfully logged into SSH server %s\n"),
|
|
1168 request->hostname);
|
1
|
1169
|
64
|
1170 if (sshv2_getcwd (request) < 0)
|
|
1171 {
|
|
1172 if (request->directory)
|
|
1173 g_free (request->directory);
|
|
1174
|
|
1175 request->directory = g_strdup (".");
|
84
|
1176 if ((ret = sshv2_getcwd (request)) < 0)
|
64
|
1177 {
|
|
1178 gftp_disconnect (request);
|
84
|
1179 return (ret);
|
64
|
1180 }
|
|
1181 }
|
1
|
1182
|
|
1183 return (0);
|
|
1184 }
|
|
1185
|
|
1186
|
|
1187 static void
|
|
1188 sshv2_disconnect (gftp_request * request)
|
|
1189 {
|
|
1190 sshv2_params * params;
|
|
1191
|
|
1192 g_return_if_fail (request != NULL);
|
|
1193 g_return_if_fail (request->protonum == GFTP_SSHV2_NUM);
|
|
1194
|
|
1195 params = request->protocol_data;
|
|
1196
|
169
|
1197 if (request->datafd > 0)
|
1
|
1198 {
|
186
|
1199 request->logging_function (gftp_logging_misc, request,
|
1
|
1200 _("Disconnecting from site %s\n"),
|
|
1201 request->hostname);
|
58
|
1202
|
169
|
1203 if (close (request->datafd) < 0)
|
186
|
1204 request->logging_function (gftp_logging_error, request,
|
58
|
1205 _("Error closing file descriptor: %s\n"),
|
|
1206 g_strerror (errno));
|
|
1207
|
169
|
1208 request->datafd = -1;
|
1
|
1209 }
|
|
1210
|
|
1211 if (params->message.buffer != NULL)
|
487
|
1212 {
|
|
1213 sshv2_message_free (¶ms->message);
|
|
1214 params->message.buffer = NULL;
|
|
1215 }
|
1
|
1216 }
|
|
1217
|
|
1218
|
|
1219 static int
|
|
1220 sshv2_end_transfer (gftp_request * request)
|
|
1221 {
|
|
1222 sshv2_params * params;
|
|
1223 sshv2_message message;
|
516
|
1224 guint32 len;
|
84
|
1225 int ret;
|
1
|
1226
|
84
|
1227 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1228 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
1
|
1229
|
|
1230 params = request->protocol_data;
|
|
1231 if (params->message.buffer != NULL)
|
|
1232 {
|
|
1233 sshv2_message_free (¶ms->message);
|
487
|
1234 params->message.buffer = NULL;
|
1
|
1235 params->count = 0;
|
|
1236 }
|
|
1237
|
|
1238 if (params->handle_len > 0)
|
|
1239 {
|
|
1240 len = htonl (params->id++);
|
|
1241 memcpy (params->handle, &len, 4);
|
|
1242
|
84
|
1243 if ((ret = sshv2_send_command (request, SSH_FXP_CLOSE, params->handle,
|
|
1244 params->handle_len)) < 0)
|
|
1245 return (ret);
|
1
|
1246
|
487
|
1247 ret = sshv2_read_status_response (request, &message, -1, 0,
|
|
1248 SSH_FXP_STATUS);
|
|
1249 if (ret < 0)
|
|
1250 return (ret);
|
|
1251
|
1
|
1252 sshv2_message_free (&message);
|
|
1253 params->handle_len = 0;
|
|
1254 }
|
|
1255
|
538
|
1256 if (params->transfer_buffer != NULL)
|
1
|
1257 {
|
538
|
1258 g_free (params->transfer_buffer);
|
|
1259 params->transfer_buffer = NULL;
|
1
|
1260 }
|
|
1261
|
|
1262 return (0);
|
|
1263 }
|
|
1264
|
|
1265
|
|
1266 static int
|
|
1267 sshv2_list_files (gftp_request * request)
|
|
1268 {
|
|
1269 sshv2_params * params;
|
|
1270 sshv2_message message;
|
|
1271 char *tempstr;
|
840
|
1272 size_t msglen;
|
64
|
1273 int ret;
|
1
|
1274
|
84
|
1275 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1276 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
169
|
1277 g_return_val_if_fail (request->datafd > 0, GFTP_EFATAL);
|
1
|
1278
|
|
1279 params = request->protocol_data;
|
|
1280
|
186
|
1281 request->logging_function (gftp_logging_misc, request,
|
1
|
1282 _("Retrieving directory listing...\n"));
|
|
1283
|
849
|
1284 msglen = 0;
|
840
|
1285 tempstr = sshv2_initialize_buffer_with_i18n_string (request,
|
|
1286 request->directory,
|
|
1287 &msglen);
|
839
|
1288 ret = sshv2_send_command (request, SSH_FXP_OPENDIR, tempstr, msglen);
|
1
|
1289 g_free (tempstr);
|
84
|
1290 if (ret < 0)
|
|
1291 return (ret);
|
487
|
1292
|
|
1293 ret = sshv2_read_status_response (request, &message, -1, SSH_FXP_STATUS,
|
|
1294 SSH_FXP_HANDLE);
|
|
1295 if (ret < 0)
|
|
1296 return (ret);
|
1
|
1297
|
|
1298 if (message.length - 4 > SSH_MAX_HANDLE_SIZE)
|
|
1299 {
|
186
|
1300 request->logging_function (gftp_logging_error, request,
|
1
|
1301 _("Error: Message size %d too big from server\n"),
|
|
1302 message.length - 4);
|
|
1303 sshv2_message_free (&message);
|
|
1304 gftp_disconnect (request);
|
84
|
1305 return (GFTP_EFATAL);
|
1
|
1306 }
|
|
1307
|
|
1308 memset (params->handle, 0, 4);
|
|
1309 memcpy (params->handle + 4, message.buffer + 4, message.length - 5);
|
|
1310 params->handle_len = message.length - 1;
|
|
1311 sshv2_message_free (&message);
|
|
1312 params->count = 0;
|
|
1313 return (0);
|
|
1314 }
|
|
1315
|
|
1316
|
|
1317 static int
|
498
|
1318 sshv2_decode_file_attributes (gftp_request * request, sshv2_message * message,
|
|
1319 gftp_file * fle)
|
|
1320 {
|
654
|
1321 guint32 attrs, num, count, i;
|
525
|
1322 int ret;
|
498
|
1323
|
654
|
1324 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &attrs)) < 0)
|
525
|
1325 return (ret);
|
498
|
1326
|
|
1327 if (attrs & SSH_FILEXFER_ATTR_SIZE)
|
|
1328 {
|
654
|
1329 if ((ret = sshv2_buffer_get_int64 (request, message, 0, 0, &fle->size)) < 0)
|
525
|
1330 return (ret);
|
498
|
1331 }
|
|
1332
|
|
1333 if (attrs & SSH_FILEXFER_ATTR_UIDGID)
|
|
1334 {
|
654
|
1335 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &num)) < 0)
|
525
|
1336 return (ret);
|
654
|
1337 fle->user = g_strdup_printf ("%d", num);
|
498
|
1338
|
654
|
1339 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &num)) < 0)
|
525
|
1340 return (ret);
|
654
|
1341 fle->group = g_strdup_printf ("%d", num);
|
498
|
1342 }
|
|
1343
|
|
1344 if (attrs & SSH_FILEXFER_ATTR_PERMISSIONS)
|
|
1345 {
|
654
|
1346 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &num)) < 0)
|
525
|
1347 return (ret);
|
500
|
1348
|
|
1349 fle->st_mode = num;
|
498
|
1350 }
|
|
1351
|
|
1352 if (attrs & SSH_FILEXFER_ATTR_ACMODTIME)
|
|
1353 {
|
654
|
1354 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, NULL)) < 0)
|
498
|
1355 return (num);
|
|
1356
|
654
|
1357 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &num)) < 0)
|
525
|
1358 return (ret);
|
498
|
1359
|
|
1360 fle->datetime = num;
|
|
1361 }
|
|
1362
|
|
1363 if (attrs & SSH_FILEXFER_ATTR_EXTENDED)
|
|
1364 {
|
654
|
1365 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0, &count)) < 0)
|
525
|
1366 return (ret);
|
498
|
1367
|
|
1368 for (i=0; i<count; i++)
|
|
1369 {
|
654
|
1370 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0,
|
|
1371 &num)) < 0 ||
|
498
|
1372 message->pos + num + 4 > message->end)
|
|
1373 return (GFTP_EFATAL);
|
|
1374
|
|
1375 message->pos += num + 4;
|
|
1376
|
654
|
1377 if ((ret = sshv2_buffer_get_int32 (request, message, 0, 0,
|
|
1378 &num)) < 0 ||
|
498
|
1379 message->pos + num + 4 > message->end)
|
|
1380 return (GFTP_EFATAL);
|
|
1381
|
|
1382 message->pos += num + 4;
|
|
1383 }
|
|
1384 }
|
|
1385
|
|
1386 return (0);
|
|
1387 }
|
|
1388
|
|
1389
|
|
1390 static int
|
58
|
1391 sshv2_get_next_file (gftp_request * request, gftp_file * fle, int fd)
|
1
|
1392 {
|
525
|
1393 int ret, retsize, iret;
|
1
|
1394 sshv2_params *params;
|
654
|
1395 char *stpos;
|
|
1396 guint32 len;
|
1
|
1397
|
84
|
1398 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1399 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1400 g_return_val_if_fail (fle != NULL, GFTP_EFATAL);
|
1
|
1401
|
|
1402 params = request->protocol_data;
|
|
1403
|
|
1404 if (request->last_dir_entry)
|
|
1405 {
|
|
1406 g_free (request->last_dir_entry);
|
|
1407 request->last_dir_entry = NULL;
|
|
1408 request->last_dir_entry_len = 0;
|
|
1409 }
|
|
1410 retsize = 0;
|
|
1411
|
|
1412 if (params->count > 0)
|
|
1413 ret = SSH_FXP_NAME;
|
|
1414 else
|
|
1415 {
|
|
1416 if (!request->cached)
|
|
1417 {
|
|
1418 if (params->message.buffer != NULL)
|
|
1419 sshv2_message_free (¶ms->message);
|
|
1420
|
|
1421 len = htonl (params->id++);
|
|
1422 memcpy (params->handle, &len, 4);
|
|
1423
|
84
|
1424 if ((ret = sshv2_send_command (request, SSH_FXP_READDIR,
|
|
1425 params->handle,
|
|
1426 params->handle_len)) < 0)
|
|
1427 return (ret);
|
1
|
1428 }
|
|
1429
|
|
1430 if ((ret = sshv2_read_response (request, ¶ms->message, fd)) < 0)
|
84
|
1431 return (ret);
|
1
|
1432
|
|
1433 if (!request->cached)
|
|
1434 {
|
|
1435 request->last_dir_entry = g_malloc (params->message.length + 4);
|
|
1436 len = htonl (params->message.length);
|
|
1437 memcpy (request->last_dir_entry, &len, 4);
|
|
1438 request->last_dir_entry[4] = params->message.command;
|
|
1439 memcpy (request->last_dir_entry + 5, params->message.buffer,
|
|
1440 params->message.length - 1);
|
|
1441 request->last_dir_entry_len = params->message.length + 4;
|
|
1442 }
|
|
1443
|
|
1444 if (ret == SSH_FXP_NAME)
|
|
1445 {
|
|
1446 params->message.pos = params->message.buffer + 4;
|
525
|
1447 if ((iret = sshv2_buffer_get_int32 (request,
|
654
|
1448 ¶ms->message, 0, 0,
|
525
|
1449 ¶ms->count)) < 0)
|
|
1450 return (iret);
|
1
|
1451 }
|
|
1452 }
|
|
1453
|
|
1454 if (ret == SSH_FXP_NAME)
|
|
1455 {
|
654
|
1456 stpos = params->message.pos;
|
|
1457 if ((fle->file = sshv2_buffer_get_string (request, ¶ms->message, 1)) == NULL)
|
84
|
1458 return (GFTP_EFATAL);
|
1
|
1459
|
654
|
1460 sshv2_buffer_get_string (request, ¶ms->message, 0);
|
498
|
1461
|
|
1462 if ((ret = sshv2_decode_file_attributes (request, ¶ms->message,
|
|
1463 fle)) < 0)
|
|
1464 {
|
598
|
1465 gftp_file_destroy (fle, 0);
|
498
|
1466 return (ret);
|
|
1467 }
|
|
1468
|
654
|
1469 retsize = params->message.pos - stpos;
|
1
|
1470 params->count--;
|
|
1471 }
|
|
1472 else if (ret == SSH_FXP_STATUS)
|
|
1473 {
|
|
1474 sshv2_message_free (¶ms->message);
|
|
1475 return (0);
|
|
1476 }
|
|
1477 else
|
493
|
1478 return (sshv2_wrong_response (request, ¶ms->message));
|
1
|
1479
|
|
1480 return (retsize);
|
|
1481 }
|
|
1482
|
|
1483
|
|
1484 static int
|
|
1485 sshv2_chdir (gftp_request * request, const char *directory)
|
|
1486 {
|
|
1487 sshv2_message message;
|
|
1488 char *tempstr, *dir;
|
|
1489 size_t len;
|
64
|
1490 int ret;
|
1
|
1491
|
84
|
1492 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1493 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
1
|
1494
|
787
|
1495 len = 0;
|
|
1496 tempstr = sshv2_initialize_string_with_path (request, directory, &len, NULL);
|
1
|
1497
|
787
|
1498 ret = sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, len);
|
1
|
1499
|
787
|
1500 g_free (tempstr);
|
|
1501 if (ret < 0)
|
|
1502 return (ret);
|
487
|
1503
|
787
|
1504 ret = sshv2_read_status_response (request, &message, -1, SSH_FXP_STATUS,
|
|
1505 SSH_FXP_NAME);
|
|
1506 if (ret < 0)
|
|
1507 return (ret);
|
1
|
1508
|
787
|
1509 message.pos += 4;
|
|
1510 if ((ret = sshv2_buffer_get_int32 (request, &message, 1, 1, NULL)) < 0)
|
|
1511 return (ret);
|
1
|
1512
|
787
|
1513 if ((dir = sshv2_buffer_get_string (request, &message, 1)) == NULL)
|
|
1514 return (GFTP_EFATAL);
|
487
|
1515
|
787
|
1516 if (request->directory)
|
|
1517 g_free (request->directory);
|
284
|
1518
|
787
|
1519 request->directory = dir;
|
|
1520 sshv2_message_free (&message);
|
284
|
1521 return (0);
|
1
|
1522 }
|
|
1523
|
|
1524
|
|
1525 static int
|
|
1526 sshv2_rmdir (gftp_request * request, const char *directory)
|
|
1527 {
|
|
1528 sshv2_message message;
|
|
1529 char *tempstr;
|
|
1530 size_t len;
|
84
|
1531 int ret;
|
1
|
1532
|
84
|
1533 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1534 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1535 g_return_val_if_fail (directory != NULL, GFTP_EFATAL);
|
1
|
1536
|
487
|
1537 len = 0;
|
489
|
1538 tempstr = sshv2_initialize_string_with_path (request, directory, &len, NULL);
|
1
|
1539
|
487
|
1540 ret = sshv2_send_command (request, SSH_FXP_RMDIR, tempstr, len);
|
1
|
1541
|
|
1542 g_free (tempstr);
|
487
|
1543 if (ret < 0)
|
|
1544 return (ret);
|
1
|
1545
|
|
1546 memset (&message, 0, sizeof (message));
|
84
|
1547 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1548 return (ret);
|
1
|
1549
|
|
1550 message.pos += 4;
|
654
|
1551 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, NULL)) < 0)
|
84
|
1552 return (ret);
|
1
|
1553
|
|
1554 sshv2_message_free (&message);
|
|
1555
|
|
1556 return (0);
|
|
1557 }
|
|
1558
|
|
1559
|
|
1560 static int
|
|
1561 sshv2_rmfile (gftp_request * request, const char *file)
|
|
1562 {
|
|
1563 sshv2_message message;
|
|
1564 char *tempstr;
|
|
1565 size_t len;
|
84
|
1566 int ret;
|
1
|
1567
|
84
|
1568 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1569 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1570 g_return_val_if_fail (file != NULL, GFTP_EFATAL);
|
1
|
1571
|
487
|
1572 len = 0;
|
489
|
1573 tempstr = sshv2_initialize_string_with_path (request, file, &len, NULL);
|
1
|
1574
|
487
|
1575 ret = sshv2_send_command (request, SSH_FXP_REMOVE, tempstr, len);
|
1
|
1576
|
|
1577 g_free (tempstr);
|
487
|
1578 if (ret < 0)
|
|
1579 return (ret);
|
1
|
1580
|
|
1581 memset (&message, 0, sizeof (message));
|
84
|
1582 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1583 return (ret);
|
1
|
1584
|
|
1585 message.pos += 4;
|
654
|
1586 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, NULL)) < 0)
|
84
|
1587 return (ret);
|
1
|
1588
|
|
1589 sshv2_message_free (&message);
|
|
1590
|
|
1591 return (0);
|
|
1592 }
|
|
1593
|
|
1594
|
|
1595 static int
|
499
|
1596 sshv2_chmod (gftp_request * request, const char *file, mode_t mode)
|
1
|
1597 {
|
531
|
1598 char *tempstr, *endpos;
|
1
|
1599 sshv2_message message;
|
516
|
1600 guint32 num;
|
1
|
1601 size_t len;
|
84
|
1602 int ret;
|
1
|
1603
|
84
|
1604 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1605 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1606 g_return_val_if_fail (file != NULL, GFTP_EFATAL);
|
1
|
1607
|
489
|
1608 len = 8; /* For attributes */
|
|
1609 tempstr = sshv2_initialize_string_with_path (request, file, &len, &endpos);
|
1
|
1610
|
|
1611 num = htonl (SSH_FILEXFER_ATTR_PERMISSIONS);
|
489
|
1612 memcpy (endpos, &num, 4);
|
1
|
1613
|
531
|
1614 num = htonl (mode);
|
489
|
1615 memcpy (endpos + 4, &num, 4);
|
|
1616
|
|
1617 ret = sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len);
|
1
|
1618
|
|
1619 g_free (tempstr);
|
489
|
1620 if (ret < 0)
|
|
1621 return (ret);
|
1
|
1622
|
|
1623 memset (&message, 0, sizeof (message));
|
84
|
1624 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1625 return (ret);
|
1
|
1626
|
|
1627 message.pos += 4;
|
654
|
1628 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, NULL)) < 0)
|
84
|
1629 return (ret);
|
1
|
1630
|
|
1631 sshv2_message_free (&message);
|
|
1632
|
|
1633 return (0);
|
|
1634 }
|
|
1635
|
|
1636
|
|
1637 static int
|
|
1638 sshv2_mkdir (gftp_request * request, const char *newdir)
|
|
1639 {
|
|
1640 sshv2_message message;
|
|
1641 char *tempstr;
|
|
1642 size_t len;
|
84
|
1643 int ret;
|
1
|
1644
|
84
|
1645 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1646 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1647 g_return_val_if_fail (newdir != NULL, GFTP_EFATAL);
|
1
|
1648
|
489
|
1649 len = 4; /* For attributes */
|
|
1650 tempstr = sshv2_initialize_string_with_path (request, newdir, &len, NULL);
|
|
1651
|
|
1652 /* No need to set attributes since all characters of the tempstr buffer is
|
|
1653 initialized to 0 */
|
1
|
1654
|
489
|
1655 ret = sshv2_send_command (request, SSH_FXP_MKDIR, tempstr, len);
|
1
|
1656
|
|
1657 g_free (tempstr);
|
489
|
1658 if (ret < 0)
|
|
1659 return (ret);
|
1
|
1660
|
|
1661 memset (&message, 0, sizeof (message));
|
84
|
1662 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1663 return (ret);
|
1
|
1664
|
|
1665 message.pos += 4;
|
654
|
1666 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, NULL)) < 0)
|
84
|
1667 return (ret);
|
1
|
1668
|
|
1669 sshv2_message_free (&message);
|
|
1670
|
|
1671 return (0);
|
|
1672 }
|
|
1673
|
|
1674
|
|
1675 static int
|
|
1676 sshv2_rename (gftp_request * request, const char *oldname, const char *newname)
|
|
1677 {
|
|
1678 sshv2_message message;
|
840
|
1679 char *tempstr;
|
|
1680 size_t msglen;
|
84
|
1681 int ret;
|
1
|
1682
|
84
|
1683 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1684 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1685 g_return_val_if_fail (oldname != NULL, GFTP_EFATAL);
|
|
1686 g_return_val_if_fail (newname != NULL, GFTP_EFATAL);
|
1
|
1687
|
849
|
1688 msglen = 0;
|
840
|
1689 tempstr = sshv2_initialize_buffer_with_two_i18n_paths (request,
|
|
1690 oldname, newname,
|
|
1691 &msglen);
|
|
1692 ret = sshv2_send_command (request, SSH_FXP_RENAME, tempstr, msglen);
|
1
|
1693 g_free (tempstr);
|
489
|
1694 if (ret < 0)
|
|
1695 return (ret);
|
1
|
1696
|
|
1697 memset (&message, 0, sizeof (message));
|
84
|
1698 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1699 return (ret);
|
1
|
1700
|
|
1701 message.pos += 4;
|
840
|
1702 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1,
|
|
1703 NULL)) < 0)
|
84
|
1704 return (ret);
|
1
|
1705
|
|
1706 sshv2_message_free (&message);
|
|
1707
|
|
1708 return (0);
|
|
1709 }
|
|
1710
|
|
1711
|
|
1712 static int
|
|
1713 sshv2_set_file_time (gftp_request * request, const char *file, time_t datetime)
|
|
1714 {
|
489
|
1715 char *tempstr, *endpos;
|
1
|
1716 sshv2_message message;
|
516
|
1717 guint32 num;
|
1
|
1718 size_t len;
|
84
|
1719 int ret;
|
1
|
1720
|
84
|
1721 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1722 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
|
1723 g_return_val_if_fail (file != NULL, GFTP_EFATAL);
|
1
|
1724
|
489
|
1725 len = 12; /* For date/time */
|
|
1726 tempstr = sshv2_initialize_string_with_path (request, file, &len, &endpos);
|
1
|
1727
|
|
1728 num = htonl (SSH_FILEXFER_ATTR_ACMODTIME);
|
489
|
1729 memcpy (endpos, &num, 4);
|
1
|
1730
|
|
1731 num = htonl (datetime);
|
489
|
1732 memcpy (endpos + 4, &num, 4);
|
|
1733 memcpy (endpos + 8, &num, 4);
|
1
|
1734
|
489
|
1735 ret = sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len);
|
|
1736
|
1
|
1737 g_free (tempstr);
|
489
|
1738 if (ret < 0)
|
|
1739 return (ret);
|
1
|
1740
|
|
1741 memset (&message, 0, sizeof (message));
|
84
|
1742 if ((ret = sshv2_read_response (request, &message, -1)) < 0)
|
|
1743 return (ret);
|
1
|
1744
|
|
1745 message.pos += 4;
|
654
|
1746 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, NULL)) < 0)
|
84
|
1747 return (ret);
|
1
|
1748
|
|
1749 sshv2_message_free (&message);
|
|
1750
|
|
1751 return (0);
|
|
1752 }
|
|
1753
|
|
1754
|
500
|
1755 static int
|
|
1756 sshv2_send_stat_command (gftp_request * request, const char *filename,
|
|
1757 gftp_file * fle)
|
1
|
1758 {
|
487
|
1759 sshv2_message message;
|
1
|
1760 char *tempstr;
|
516
|
1761 size_t len;
|
500
|
1762 int ret;
|
1
|
1763
|
84
|
1764 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1765 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
500
|
1766 g_return_val_if_fail (filename != NULL, GFTP_EFATAL);
|
1
|
1767
|
487
|
1768 len = 0;
|
500
|
1769 tempstr = sshv2_initialize_string_with_path (request, filename, &len, NULL);
|
487
|
1770
|
|
1771 ret = sshv2_send_command (request, SSH_FXP_STAT, tempstr, len);
|
1
|
1772
|
487
|
1773 g_free (tempstr);
|
|
1774 if (ret < 0)
|
|
1775 return (ret);
|
1
|
1776
|
500
|
1777 ret = sshv2_read_status_response (request, &message, -1, SSH_FXP_STATUS,
|
|
1778 SSH_FXP_ATTRS);
|
|
1779 if (ret < 0)
|
|
1780 return (ret);
|
487
|
1781
|
|
1782 if (message.length < 5)
|
|
1783 return (GFTP_EFATAL);
|
1
|
1784
|
487
|
1785 message.pos += 4;
|
500
|
1786 if ((ret = sshv2_decode_file_attributes (request, &message, fle)) < 0)
|
1
|
1787 {
|
598
|
1788 gftp_file_destroy (fle, 0);
|
500
|
1789 return (ret);
|
1
|
1790 }
|
|
1791
|
487
|
1792 sshv2_message_free (&message);
|
1
|
1793
|
500
|
1794 return (0);
|
|
1795 }
|
|
1796
|
|
1797
|
520
|
1798 static int
|
|
1799 sshv2_stat_filename (gftp_request * request, const char *filename,
|
787
|
1800 mode_t * mode, off_t * filesize)
|
500
|
1801 {
|
|
1802 gftp_file fle;
|
526
|
1803 int ret;
|
500
|
1804
|
|
1805 memset (&fle, 0, sizeof (fle));
|
|
1806 ret = sshv2_send_stat_command (request, filename, &fle);
|
|
1807 if (ret < 0)
|
|
1808 return (ret);
|
|
1809
|
520
|
1810 *mode = fle.st_mode;
|
787
|
1811 *filesize = fle.size;
|
|
1812
|
598
|
1813 gftp_file_destroy (&fle, 0);
|
500
|
1814
|
520
|
1815 return (0);
|
500
|
1816 }
|
1
|
1817
|
500
|
1818
|
|
1819 static off_t
|
|
1820 sshv2_get_file_size (gftp_request * request, const char *file)
|
|
1821 {
|
|
1822 gftp_file fle;
|
|
1823 off_t size;
|
|
1824 int ret;
|
|
1825
|
|
1826 memset (&fle, 0, sizeof (fle));
|
|
1827 ret = sshv2_send_stat_command (request, file, &fle);
|
|
1828 if (ret < 0)
|
|
1829 return (ret);
|
|
1830
|
|
1831 size = fle.size;
|
598
|
1832 gftp_file_destroy (&fle, 0);
|
500
|
1833
|
|
1834 return (size);
|
1
|
1835 }
|
|
1836
|
|
1837
|
537
|
1838 static int
|
|
1839 sshv2_open_file (gftp_request * request, const char *file, off_t startsize,
|
|
1840 guint32 mode)
|
1
|
1841 {
|
489
|
1842 char *tempstr, *endpos;
|
1
|
1843 sshv2_params * params;
|
|
1844 sshv2_message message;
|
516
|
1845 guint32 num;
|
489
|
1846 size_t len;
|
64
|
1847 int ret;
|
1
|
1848
|
84
|
1849 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1850 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
169
|
1851 g_return_val_if_fail (request->datafd > 0, GFTP_EFATAL);
|
1
|
1852
|
|
1853 params = request->protocol_data;
|
|
1854 params->offset = startsize;
|
|
1855
|
849
|
1856 len = 8; /* For mode */
|
489
|
1857 tempstr = sshv2_initialize_string_with_path (request, file, &len, &endpos);
|
1
|
1858
|
537
|
1859 num = htonl (mode);
|
489
|
1860 memcpy (endpos, &num, 4);
|
1
|
1861
|
489
|
1862 ret = sshv2_send_command (request, SSH_FXP_OPEN, tempstr, len);
|
1
|
1863
|
|
1864 g_free (tempstr);
|
84
|
1865 if (ret < 0)
|
|
1866 return (ret);
|
489
|
1867
|
|
1868 ret = sshv2_read_status_response (request, &message, -1, SSH_FXP_STATUS,
|
|
1869 SSH_FXP_HANDLE);
|
|
1870 if (ret < 0)
|
|
1871 return (ret);
|
1
|
1872
|
|
1873 if (message.length - 4 > SSH_MAX_HANDLE_SIZE)
|
|
1874 {
|
186
|
1875 request->logging_function (gftp_logging_error, request,
|
1
|
1876 _("Error: Message size %d too big from server\n"),
|
|
1877 message.length - 4);
|
|
1878 sshv2_message_free (&message);
|
|
1879 gftp_disconnect (request);
|
84
|
1880 return (GFTP_ERETRYABLE);
|
1
|
1881
|
|
1882 }
|
|
1883
|
|
1884 memset (params->handle, 0, 4);
|
321
|
1885 memcpy (params->handle + 4, message.buffer + 4, message.length - 5);
|
1
|
1886 params->handle_len = message.length - 1;
|
|
1887 sshv2_message_free (&message);
|
|
1888
|
|
1889 return (0);
|
|
1890 }
|
|
1891
|
|
1892
|
537
|
1893 static off_t
|
|
1894 sshv2_get_file (gftp_request * request, const char *file, int fd,
|
|
1895 off_t startsize)
|
|
1896 {
|
|
1897 int ret;
|
|
1898
|
746
|
1899 if ((ret = sshv2_open_file (request, file, startsize, SSH_FXF_READ)) < 0)
|
537
|
1900 return (ret);
|
|
1901
|
|
1902 return (sshv2_get_file_size (request, file));
|
|
1903 }
|
|
1904
|
|
1905
|
|
1906 static int
|
|
1907 sshv2_put_file (gftp_request * request, const char *file, int fd,
|
|
1908 off_t startsize, off_t totalsize)
|
|
1909 {
|
|
1910 guint32 mode;
|
|
1911 int ret;
|
|
1912
|
|
1913 if (startsize > 0)
|
|
1914 mode = SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_APPEND;
|
|
1915 else
|
|
1916 mode = SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC;
|
|
1917
|
|
1918 if ((ret = sshv2_open_file (request, file, startsize, mode)) < 0)
|
|
1919 return (ret);
|
|
1920
|
|
1921 return (0);
|
|
1922 }
|
|
1923
|
|
1924
|
518
|
1925 static void
|
528
|
1926 sshv2_setup_file_offset (sshv2_params * params, char *buf)
|
518
|
1927 {
|
|
1928 guint32 hinum, lownum;
|
|
1929 #ifdef G_HAVE_GINT64
|
747
|
1930 hinum = htonl(params->offset >> 32);
|
|
1931 lownum = htonl((guint32) params->offset);
|
518
|
1932 #else
|
|
1933 hinum = 0;
|
|
1934 lownum = htonl (params->offset);
|
|
1935 #endif
|
|
1936
|
528
|
1937 memcpy (buf + params->handle_len, &hinum, 4);
|
|
1938 memcpy (buf + params->handle_len + 4, &lownum, 4);
|
518
|
1939 }
|
|
1940
|
|
1941
|
58
|
1942 static ssize_t
|
1
|
1943 sshv2_get_next_file_chunk (gftp_request * request, char *buf, size_t size)
|
|
1944 {
|
|
1945 sshv2_params * params;
|
|
1946 sshv2_message message;
|
516
|
1947 guint32 num;
|
84
|
1948 int ret;
|
1
|
1949
|
84
|
1950 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
1951 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
169
|
1952 g_return_val_if_fail (request->datafd > 0, GFTP_EFATAL);
|
84
|
1953 g_return_val_if_fail (buf != NULL, GFTP_EFATAL);
|
1
|
1954
|
|
1955 params = request->protocol_data;
|
|
1956
|
538
|
1957 if (params->transfer_buffer == NULL)
|
1
|
1958 {
|
538
|
1959 params->transfer_buffer_len = params->handle_len + 12;
|
|
1960 params->transfer_buffer = g_malloc (params->transfer_buffer_len);
|
|
1961 memcpy (params->transfer_buffer, params->handle, params->handle_len);
|
1
|
1962 }
|
|
1963
|
|
1964 num = htonl (params->id++);
|
538
|
1965 memcpy (params->transfer_buffer, &num, 4);
|
1
|
1966
|
538
|
1967 sshv2_setup_file_offset (params, params->transfer_buffer);
|
518
|
1968
|
1
|
1969 num = htonl (size);
|
538
|
1970 memcpy (params->transfer_buffer + params->handle_len + 8, &num, 4);
|
1
|
1971
|
538
|
1972 if ((ret = sshv2_send_command (request, SSH_FXP_READ, params->transfer_buffer,
|
|
1973 params->handle_len + 12)) < 0)
|
|
1974 return (ret);
|
1
|
1975
|
|
1976 memset (&message, 0, sizeof (message));
|
84
|
1977 if ((ret = sshv2_read_response (request, &message, -1)) != SSH_FXP_DATA)
|
1
|
1978 {
|
84
|
1979 if (ret < 0)
|
|
1980 return (ret);
|
|
1981
|
1
|
1982 message.pos += 4;
|
654
|
1983 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_EOF, 1,
|
525
|
1984 NULL)) < 0)
|
|
1985 return (ret);
|
498
|
1986
|
525
|
1987 sshv2_message_free (&message);
|
1
|
1988 return (0);
|
|
1989 }
|
|
1990
|
|
1991 memcpy (&num, message.buffer + 4, 4);
|
|
1992 num = ntohl (num);
|
|
1993 if (num > size)
|
|
1994 {
|
186
|
1995 request->logging_function (gftp_logging_error, request,
|
1
|
1996 _("Error: Message size %d too big from server\n"),
|
|
1997 num);
|
|
1998 sshv2_message_free (&message);
|
|
1999 gftp_disconnect (request);
|
84
|
2000 return (GFTP_ERETRYABLE);
|
1
|
2001
|
|
2002 }
|
|
2003
|
|
2004 memcpy (buf, message.buffer + 8, num);
|
|
2005 sshv2_message_free (&message);
|
|
2006 params->offset += num;
|
|
2007 return (num);
|
|
2008 }
|
|
2009
|
|
2010
|
58
|
2011 static ssize_t
|
1
|
2012 sshv2_put_next_file_chunk (gftp_request * request, char *buf, size_t size)
|
|
2013 {
|
|
2014 sshv2_params * params;
|
|
2015 sshv2_message message;
|
516
|
2016 guint32 num;
|
1
|
2017 int ret;
|
|
2018
|
84
|
2019 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
|
2020 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL);
|
169
|
2021 g_return_val_if_fail (request->datafd > 0, GFTP_EFATAL);
|
84
|
2022 g_return_val_if_fail (buf != NULL, GFTP_EFATAL);
|
1
|
2023
|
|
2024 params = request->protocol_data;
|
|
2025
|
538
|
2026 if (params->transfer_buffer == NULL)
|
|
2027 {
|
|
2028 params->transfer_buffer_len = params->handle_len + size + 12;
|
|
2029 params->transfer_buffer = g_malloc (params->transfer_buffer_len);
|
|
2030 memcpy (params->transfer_buffer, params->handle, params->handle_len);
|
|
2031 }
|
1
|
2032
|
|
2033 num = htonl (params->id++);
|
538
|
2034 memcpy (params->transfer_buffer, &num, 4);
|
1
|
2035
|
538
|
2036 sshv2_setup_file_offset (params, params->transfer_buffer);
|
|
2037
|
1
|
2038 num = htonl (size);
|
538
|
2039 memcpy (params->transfer_buffer + params->handle_len + 8, &num, 4);
|
|
2040 memcpy (params->transfer_buffer + params->handle_len + 12, buf, size);
|
1
|
2041
|
538
|
2042 if ((ret = sshv2_send_command (request, SSH_FXP_WRITE,
|
|
2043 params->transfer_buffer,
|
|
2044 params->transfer_buffer_len)) < 0)
|
|
2045 return (ret);
|
1
|
2046
|
|
2047 memset (&message, 0, sizeof (message));
|
|
2048 params->dont_log_status = 1;
|
58
|
2049 ret = sshv2_read_response (request, &message, -1);
|
84
|
2050 if (ret < 0)
|
|
2051 return (ret);
|
|
2052
|
1
|
2053 params->dont_log_status = 0;
|
|
2054 if (ret != SSH_FXP_STATUS)
|
493
|
2055 return (sshv2_wrong_response (request, &message));
|
1
|
2056
|
|
2057 message.pos += 4;
|
654
|
2058 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK, 1, &num)) < 0)
|
525
|
2059 {
|
|
2060 if (num == SSH_FX_EOF)
|
|
2061 return (0);
|
1
|
2062
|
525
|
2063 return (ret);
|
|
2064 }
|
1
|
2065
|
525
|
2066 sshv2_message_free (&message);
|
1
|
2067 params->offset += size;
|
|
2068 return (size);
|
|
2069 }
|
|
2070
|
48
|
2071
|
177
|
2072 static int
|
58
|
2073 sshv2_set_config_options (gftp_request * request)
|
|
2074 {
|
325
|
2075 intptr_t ssh_need_userpass;
|
58
|
2076
|
122
|
2077 gftp_lookup_request_option (request, "ssh_need_userpass", &ssh_need_userpass);
|
553
|
2078 request->need_username = ssh_need_userpass;
|
574
|
2079 request->need_password = ssh_need_userpass;
|
177
|
2080 return (0);
|
58
|
2081 }
|
|
2082
|
|
2083
|
63
|
2084 static void
|
|
2085 sshv2_swap_socks (gftp_request * dest, gftp_request * source)
|
|
2086 {
|
|
2087 sshv2_params * sparams, * dparams;
|
|
2088
|
|
2089 sparams = source->protocol_data;
|
|
2090 dparams = dest->protocol_data;
|
|
2091 dparams->id = sparams->id;
|
|
2092 }
|
|
2093
|
|
2094
|
122
|
2095 void
|
|
2096 sshv2_register_module (void)
|
|
2097 {
|
|
2098 gftp_register_config_vars (config_vars);
|
|
2099 }
|
|
2100
|
|
2101
|
526
|
2102 static void
|
|
2103 sshv2_copy_message (sshv2_message * src_message, sshv2_message * dest_message)
|
|
2104 {
|
|
2105 dest_message->length = src_message->length;
|
|
2106 dest_message->command = src_message->command;
|
|
2107 dest_message->buffer = g_strdup (src_message->buffer);
|
|
2108 dest_message->pos = dest_message->buffer + (src_message->pos - src_message->buffer);
|
|
2109 dest_message->end = dest_message->buffer + (src_message->end - src_message->buffer);
|
|
2110 }
|
|
2111
|
|
2112
|
|
2113 static void
|
|
2114 sshv2_copy_param_options (gftp_request * dest_request,
|
|
2115 gftp_request * src_request)
|
|
2116 {
|
|
2117 sshv2_params * dparms, * sparms;
|
|
2118
|
|
2119 dparms = dest_request->protocol_data;
|
|
2120 sparms = src_request->protocol_data;
|
|
2121
|
|
2122 memcpy (dparms->handle, sparms->handle, sizeof (*dparms->handle));
|
538
|
2123 if (sparms->transfer_buffer != NULL)
|
|
2124 {
|
|
2125 dparms->transfer_buffer = g_malloc (sparms->transfer_buffer_len);
|
|
2126 memcpy (dparms->transfer_buffer, sparms->transfer_buffer,
|
|
2127 sparms->transfer_buffer_len);
|
|
2128 }
|
526
|
2129 else
|
538
|
2130 dparms->transfer_buffer = NULL;
|
526
|
2131
|
|
2132 sshv2_copy_message (&sparms->message, &dparms->message);
|
|
2133
|
|
2134 dparms->id = sparms->id;
|
|
2135 dparms->count = sparms->count;
|
|
2136 dparms->handle_len = sparms->handle_len;
|
|
2137 dparms->initialized = sparms->initialized;
|
|
2138 dparms->dont_log_status = sparms->dont_log_status;
|
|
2139 dparms->offset = sparms->offset;
|
|
2140 }
|
|
2141
|
|
2142
|
173
|
2143 int
|
48
|
2144 sshv2_init (gftp_request * request)
|
|
2145 {
|
|
2146 sshv2_params * params;
|
|
2147
|
173
|
2148 g_return_val_if_fail (request != NULL, GFTP_EFATAL);
|
48
|
2149
|
|
2150 request->protonum = GFTP_SSHV2_NUM;
|
|
2151 request->init = sshv2_init;
|
526
|
2152 request->copy_param_options = sshv2_copy_param_options;
|
48
|
2153 request->destroy = sshv2_destroy;
|
168
|
2154 request->read_function = gftp_fd_read;
|
|
2155 request->write_function = gftp_fd_write;
|
48
|
2156 request->connect = sshv2_connect;
|
168
|
2157 request->post_connect = NULL;
|
48
|
2158 request->disconnect = sshv2_disconnect;
|
|
2159 request->get_file = sshv2_get_file;
|
|
2160 request->put_file = sshv2_put_file;
|
|
2161 request->transfer_file = NULL;
|
|
2162 request->get_next_file_chunk = sshv2_get_next_file_chunk;
|
|
2163 request->put_next_file_chunk = sshv2_put_next_file_chunk;
|
|
2164 request->end_transfer = sshv2_end_transfer;
|
|
2165 request->abort_transfer = sshv2_end_transfer; /* NOTE: uses sshv2_end_transfer */
|
500
|
2166 request->stat_filename = sshv2_stat_filename;
|
48
|
2167 request->list_files = sshv2_list_files;
|
|
2168 request->get_next_file = sshv2_get_next_file;
|
485
|
2169 request->get_next_dirlist_line = NULL;
|
48
|
2170 request->get_file_size = sshv2_get_file_size;
|
|
2171 request->chdir = sshv2_chdir;
|
|
2172 request->rmdir = sshv2_rmdir;
|
|
2173 request->rmfile = sshv2_rmfile;
|
|
2174 request->mkdir = sshv2_mkdir;
|
|
2175 request->rename = sshv2_rename;
|
|
2176 request->chmod = sshv2_chmod;
|
|
2177 request->set_file_time = sshv2_set_file_time;
|
|
2178 request->site = NULL;
|
|
2179 request->parse_url = NULL;
|
58
|
2180 request->set_config_options = sshv2_set_config_options;
|
63
|
2181 request->swap_socks = sshv2_swap_socks;
|
48
|
2182 request->url_prefix = "ssh2";
|
|
2183 request->need_hostport = 1;
|
553
|
2184 request->need_username = 1;
|
|
2185 request->need_password = 1;
|
48
|
2186 request->use_cache = 1;
|
|
2187 request->always_connected = 0;
|
832
|
2188 request->use_local_encoding = 0;
|
48
|
2189 request->protocol_data = g_malloc0 (sizeof (sshv2_params));
|
122
|
2190 request->server_type = GFTP_DIRTYPE_UNIX;
|
48
|
2191
|
|
2192 params = request->protocol_data;
|
|
2193 params->id = 1;
|
173
|
2194
|
177
|
2195 return (gftp_set_config_options (request));
|
48
|
2196 }
|
487
|
2197
|