1
/* This source code was modified by Martin Hedenfalk <mhe@stacken.kth.se> for
2
* use in Curl. His latest changes were done 2000-09-18.
4
* It has since been patched and modified a lot by Daniel Stenberg
5
* <daniel@haxx.se> to make it better applied to curl conditions, and to make
6
* it not use globals, pollute name space and more. This source code awaits a
7
* rewrite to work around the paragraph 2 in the BSD licenses as explained
10
* Copyright (c) 1998, 1999 Kungliga Tekniska H�gskolan
11
* (Royal Institute of Technology, Stockholm, Sweden).
12
* All rights reserved.
14
* Redistribution and use in source and binary forms, with or without
15
* modification, are permitted provided that the following conditions
18
* 1. Redistributions of source code must retain the above copyright
19
* notice, this list of conditions and the following disclaimer.
21
* 2. Redistributions in binary form must reproduce the above copyright
22
* notice, this list of conditions and the following disclaimer in the
23
* documentation and/or other materials provided with the distribution.
25
* 3. Neither the name of the Institute nor the names of its contributors
26
* may be used to endorse or promote products derived from this software
27
* without specific prior written permission.
29
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
30
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
33
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
43
#ifndef CURL_DISABLE_FTP
46
#define _MPRINTF_REPLACE /* we want curl-functions instead of native ones */
47
#include <curl/mprintf.h>
61
#include "curl_memory.h"
63
/* The last #include file should be: */
66
#define min(a, b) ((a) < (b) ? (a) : (b))
69
enum protection_level level;
72
{ prot_clear, "clear" },
73
{ prot_safe, "safe" },
74
{ prot_confidential, "confidential" },
75
{ prot_private, "private" }
78
static enum protection_level
79
name_to_level(const char *name)
82
for(i = 0; i < (int)sizeof(level_names)/(int)sizeof(level_names[0]); i++)
83
if(!strncasecmp(level_names[i].name, name, strlen(name)))
84
return level_names[i].level;
85
return (enum protection_level)-1;
88
static struct Curl_sec_client_mech *mechs[] = {
93
&Curl_krb4_client_mech,
99
Curl_sec_getc(struct connectdata *conn, FILE *F)
101
if(conn->sec_complete && conn->data_prot) {
103
if(Curl_sec_read(conn, fileno(F), &c, 1) <= 0)
112
block_read(int fd, void *buf, size_t len)
114
unsigned char *p = buf;
117
b = read(fd, p, len);
125
return p - (unsigned char*)buf;
129
block_write(int fd, void *buf, size_t len)
131
unsigned char *p = buf;
134
b = write(fd, p, len);
140
return p - (unsigned char*)buf;
144
sec_get_data(struct connectdata *conn,
145
int fd, struct krb4buffer *buf)
150
b = block_read(fd, &len, sizeof(len));
156
buf->data = realloc(buf->data, len);
157
b = block_read(fd, buf->data, len);
162
buf->size = (conn->mech->decode)(conn->app_data, buf->data, len,
163
conn->data_prot, conn);
169
buffer_read(struct krb4buffer *buf, void *data, size_t len)
171
len = min(len, buf->size - buf->index);
172
memcpy(data, (char*)buf->data + buf->index, len);
178
buffer_write(struct krb4buffer *buf, void *data, size_t len)
180
if(buf->index + len > buf->size) {
182
if(buf->data == NULL)
185
tmp = realloc(buf->data, buf->index + len);
189
buf->size = buf->index + len;
191
memcpy((char*)buf->data + buf->index, data, len);
197
Curl_sec_read(struct connectdata *conn, int fd, void *buffer, int length)
202
if(conn->sec_complete == 0 || conn->data_prot == 0)
203
return read(fd, buffer, length);
205
if(conn->in_buffer.eof_flag){
206
conn->in_buffer.eof_flag = 0;
210
len = buffer_read(&conn->in_buffer, buffer, length);
213
buffer = (char*)buffer + len;
216
if(sec_get_data(conn, fd, &conn->in_buffer) < 0)
218
if(conn->in_buffer.size == 0) {
220
conn->in_buffer.eof_flag = 1;
223
len = buffer_read(&conn->in_buffer, buffer, length);
226
buffer = (char*)buffer + len;
232
sec_send(struct connectdata *conn, int fd, char *from, int length)
236
bytes = (conn->mech->encode)(conn->app_data, from, length, conn->data_prot,
238
bytes = htonl(bytes);
239
block_write(fd, &bytes, sizeof(bytes));
240
block_write(fd, buf, ntohl(bytes));
246
Curl_sec_fflush_fd(struct connectdata *conn, int fd)
248
if(conn->data_prot != prot_clear) {
249
if(conn->out_buffer.index > 0){
250
Curl_sec_write(conn, fd,
251
conn->out_buffer.data, conn->out_buffer.index);
252
conn->out_buffer.index = 0;
254
sec_send(conn, fd, NULL, 0);
260
Curl_sec_write(struct connectdata *conn, int fd, char *buffer, int length)
262
int len = conn->buffer_size;
265
if(conn->data_prot == prot_clear)
266
return write(fd, buffer, length);
268
len -= (conn->mech->overhead)(conn->app_data, conn->data_prot, len);
272
sec_send(conn, fd, buffer, len);
281
Curl_sec_putc(struct connectdata *conn, int c, FILE *F)
284
if(conn->data_prot == prot_clear)
287
buffer_write(&conn->out_buffer, &ch, 1);
288
if(c == '\n' || conn->out_buffer.index >= 1024 /* XXX */) {
289
Curl_sec_write(conn, fileno(F), conn->out_buffer.data,
290
conn->out_buffer.index);
291
conn->out_buffer.index = 0;
297
Curl_sec_read_msg(struct connectdata *conn, char *s, int level)
303
buf = malloc(strlen(s));
304
len = Curl_base64_decode(s + 4, buf); /* XXX */
306
len = (conn->mech->decode)(conn->app_data, buf, len, level, conn);
317
sscanf(buf, "%d", &code);
318
if(buf[len-1] == '\n')
325
enum protection_level
326
Curl_set_command_prot(struct connectdata *conn, enum protection_level level)
328
enum protection_level old = conn->command_prot;
329
conn->command_prot = level;
334
sec_prot_internal(struct connectdata *conn, int level)
337
unsigned int s = 1048576;
340
if(!conn->sec_complete){
341
infof(conn->data, "No security data exchange has taken place.\n");
347
if(Curl_ftpsendf(conn, "PBSZ %u", s))
350
if(Curl_GetFTPResponse(&nread, conn, &code))
354
failf(conn->data, "Failed to set protection buffer size.");
357
conn->buffer_size = s;
359
p = strstr(conn->data->state.buffer, "PBSZ=");
361
sscanf(p, "PBSZ=%u", &s);
362
if(s < conn->buffer_size)
363
conn->buffer_size = s;
366
if(Curl_ftpsendf(conn, "PROT %c", level["CSEP"]))
369
if(Curl_GetFTPResponse(&nread, conn, NULL))
372
if(conn->data->state.buffer[0] != '2'){
373
failf(conn->data, "Failed to set protection level.");
377
conn->data_prot = (enum protection_level)level;
382
Curl_sec_set_protection_level(struct connectdata *conn)
384
if(conn->sec_complete && conn->data_prot != conn->request_data_prot)
385
sec_prot_internal(conn, conn->request_data_prot);
390
Curl_sec_request_prot(struct connectdata *conn, const char *level)
392
int l = name_to_level(level);
395
conn->request_data_prot = (enum protection_level)l;
400
Curl_sec_login(struct connectdata *conn)
403
struct Curl_sec_client_mech **m;
405
struct SessionHandle *data=conn->data;
408
for(m = mechs; *m && (*m)->name; m++) {
411
tmp = realloc(conn->app_data, (*m)->size);
413
failf (data, "realloc %u failed", (*m)->size);
416
conn->app_data = tmp;
418
if((*m)->init && (*(*m)->init)(conn->app_data) != 0) {
419
infof(data, "Skipping %s...\n", (*m)->name);
422
infof(data, "Trying %s...\n", (*m)->name);
424
if(Curl_ftpsendf(conn, "AUTH %s", (*m)->name))
427
if(Curl_GetFTPResponse(&nread, conn, &ftpcode))
430
if(conn->data->state.buffer[0] != '3'){
434
"%s is not supported by the server.\n", (*m)->name);
437
infof(data, "%s rejected as security mechanism.\n", (*m)->name);
440
if(conn->data->state.buffer[0] == '5') {
441
infof(data, "The server doesn't support the FTP "
442
"security extensions.\n");
450
ret = (*(*m)->auth)(conn->app_data, conn);
452
if(ret == AUTH_CONTINUE)
454
else if(ret != AUTH_OK){
455
/* mechanism is supposed to output error string */
459
conn->sec_complete = 1;
460
conn->command_prot = prot_safe;
468
Curl_sec_end(struct connectdata *conn)
470
if (conn->mech != NULL) {
472
(conn->mech->end)(conn->app_data);
473
memset(conn->app_data, 0, conn->mech->size);
474
free(conn->app_data);
475
conn->app_data = NULL;
477
conn->sec_complete = 0;
478
conn->data_prot = (enum protection_level)0;
482
#endif /* HAVE_KRB4 */
483
#endif /* CURL_DISABLE_FTP */