303 lines
7.6 KiB
C
303 lines
7.6 KiB
C
/**
|
|
* @file ftp.c
|
|
* @brief Simple FTP client for ClaudeOS.
|
|
*
|
|
* Connects to an FTP server and provides a minimal interactive
|
|
* interface for sending FTP commands and viewing responses.
|
|
*
|
|
* Usage:
|
|
* ftp <ip>[:<port>]
|
|
*
|
|
* Examples:
|
|
* ftp 10.0.2.2
|
|
* ftp 192.168.1.1:2121
|
|
*
|
|
* Once connected, type FTP commands directly:
|
|
* USER anonymous
|
|
* PASS user@
|
|
* LIST
|
|
* QUIT
|
|
*
|
|
* The client handles the control connection. PASV data connections
|
|
* are not supported in this minimal version.
|
|
*/
|
|
|
|
#include "syscalls.h"
|
|
|
|
typedef unsigned char uint8_t;
|
|
|
|
/**
|
|
* Parse a decimal number from a string.
|
|
*/
|
|
static uint32_t parse_uint(const char **s) {
|
|
uint32_t val = 0;
|
|
while (**s >= '0' && **s <= '9') {
|
|
val = val * 10 + (uint32_t)(**s - '0');
|
|
(*s)++;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* Parse an IPv4 address.
|
|
*/
|
|
static uint32_t parse_ip(const char **s) {
|
|
uint32_t ip = 0;
|
|
for (int i = 0; i < 4; i++) {
|
|
uint32_t octet = parse_uint(s);
|
|
if (octet > 255) return 0;
|
|
ip = (ip << 8) | octet;
|
|
if (i < 3) {
|
|
if (**s != '.') return 0;
|
|
(*s)++;
|
|
}
|
|
}
|
|
return ip;
|
|
}
|
|
|
|
/**
|
|
* Print a decimal number.
|
|
*/
|
|
static void print_dec(uint32_t val) {
|
|
char buf[12];
|
|
int i = 0;
|
|
if (val == 0) { putchar('0'); return; }
|
|
while (val > 0) {
|
|
buf[i++] = '0' + (char)(val % 10);
|
|
val /= 10;
|
|
}
|
|
while (i > 0) putchar(buf[--i]);
|
|
}
|
|
|
|
/**
|
|
* Format IP address.
|
|
*/
|
|
static void ip_to_str(uint32_t ip, char *buf) {
|
|
int pos = 0;
|
|
for (int i = 3; i >= 0; i--) {
|
|
uint32_t octet = (ip >> (i * 8)) & 0xFF;
|
|
char tmp[4]; int ti = 0;
|
|
if (octet == 0) { tmp[ti++] = '0'; }
|
|
else { while (octet > 0) { tmp[ti++] = '0' + (char)(octet % 10); octet /= 10; } }
|
|
while (ti > 0) buf[pos++] = tmp[--ti];
|
|
if (i > 0) buf[pos++] = '.';
|
|
}
|
|
buf[pos] = '\0';
|
|
}
|
|
|
|
/**
|
|
* Read a line from stdin with echo.
|
|
* Returns length (excluding newline).
|
|
*/
|
|
static int readline(char *buf, int maxlen) {
|
|
int pos = 0;
|
|
while (pos < maxlen - 1) {
|
|
char c;
|
|
int32_t n = read(0, &c, 1);
|
|
if (n <= 0) { yield(); continue; }
|
|
if (c == '\n' || c == '\r') { putchar('\n'); break; }
|
|
if (c == '\b' || c == 127) {
|
|
if (pos > 0) { pos--; puts("\b \b"); }
|
|
} else if (c >= 32) {
|
|
buf[pos++] = c;
|
|
putchar(c);
|
|
}
|
|
}
|
|
buf[pos] = '\0';
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Receive and print FTP server response.
|
|
* Reads until we get a line starting with a 3-digit code followed by space.
|
|
* Returns the response code, or -1 on error.
|
|
*/
|
|
static int32_t recv_response(int32_t sockfd) {
|
|
char buf[512];
|
|
int total = 0;
|
|
int timeout = 500;
|
|
int code = -1;
|
|
|
|
while (timeout > 0) {
|
|
int32_t n = net_recv(sockfd, buf + total,
|
|
(uint32_t)(sizeof(buf) - 1 - (uint32_t)total));
|
|
if (n > 0) {
|
|
total += n;
|
|
buf[total] = '\0';
|
|
|
|
/* Print received data */
|
|
write(1, buf + total - n, (uint32_t)n);
|
|
|
|
/* Check if we have a complete response.
|
|
* FTP response ends when we get "NNN " (3 digits + space) at start of line. */
|
|
int got_complete = 0;
|
|
for (int i = 0; i < total; i++) {
|
|
/* Check for line start */
|
|
if (i == 0 || (i > 0 && buf[i-1] == '\n')) {
|
|
/* Check for "NNN " pattern */
|
|
if (i + 3 < total &&
|
|
buf[i] >= '0' && buf[i] <= '9' &&
|
|
buf[i+1] >= '0' && buf[i+1] <= '9' &&
|
|
buf[i+2] >= '0' && buf[i+2] <= '9' &&
|
|
buf[i+3] == ' ') {
|
|
code = (buf[i] - '0') * 100 +
|
|
(buf[i+1] - '0') * 10 +
|
|
(buf[i+2] - '0');
|
|
got_complete = 1;
|
|
}
|
|
}
|
|
}
|
|
if (got_complete) break;
|
|
timeout = 200;
|
|
} else if (n < 0) {
|
|
return -1;
|
|
} else {
|
|
yield();
|
|
timeout--;
|
|
}
|
|
}
|
|
|
|
return code;
|
|
}
|
|
|
|
/**
|
|
* Send an FTP command (appends \r\n).
|
|
*/
|
|
static int32_t send_cmd(int32_t sockfd, const char *cmd) {
|
|
char buf[256];
|
|
uint32_t len = 0;
|
|
while (cmd[len] && len < sizeof(buf) - 3) {
|
|
buf[len] = cmd[len];
|
|
len++;
|
|
}
|
|
buf[len++] = '\r';
|
|
buf[len++] = '\n';
|
|
return net_send(sockfd, buf, len);
|
|
}
|
|
|
|
int main(void) {
|
|
char arg[256];
|
|
|
|
if (getenv("ARG1", arg, sizeof(arg)) < 0 || arg[0] == '\0') {
|
|
puts("Usage: ftp <ip>[:<port>]\n");
|
|
puts(" e.g. ftp 10.0.2.2\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Parse IP and port */
|
|
const char *p = arg;
|
|
uint32_t ip = parse_ip(&p);
|
|
if (ip == 0) {
|
|
puts("ftp: invalid IP address\n");
|
|
return 1;
|
|
}
|
|
|
|
uint32_t port = 21;
|
|
if (*p == ':') {
|
|
p++;
|
|
port = parse_uint(&p);
|
|
if (port == 0 || port > 65535) {
|
|
puts("ftp: invalid port\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
char ip_str[64];
|
|
ip_to_str(ip, ip_str);
|
|
|
|
puts("Connecting to ");
|
|
puts(ip_str);
|
|
putchar(':');
|
|
print_dec(port);
|
|
puts("...\n");
|
|
|
|
/* Create TCP socket */
|
|
int32_t sockfd = socket(SOCK_TCP);
|
|
if (sockfd < 0) {
|
|
puts("ftp: failed to create socket\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Connect */
|
|
if (connect(sockfd, ip, port) < 0) {
|
|
puts("ftp: connect failed\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Wait for connection */
|
|
int timeout = 500;
|
|
while (timeout > 0) {
|
|
int32_t state = sockstate(sockfd);
|
|
if (state == TCP_STATE_ESTABLISHED) break;
|
|
if (state == TCP_STATE_CLOSED) {
|
|
puts("ftp: connection refused\n");
|
|
return 1;
|
|
}
|
|
yield();
|
|
timeout--;
|
|
}
|
|
if (timeout <= 0) {
|
|
puts("ftp: connection timed out\n");
|
|
return 1;
|
|
}
|
|
|
|
puts("Connected to ");
|
|
puts(ip_str);
|
|
puts("\n");
|
|
|
|
/* Read server welcome banner */
|
|
int32_t code = recv_response(sockfd);
|
|
if (code < 0 || code >= 400) {
|
|
puts("ftp: server rejected connection\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Interactive command loop */
|
|
char cmd[256];
|
|
for (;;) {
|
|
puts("ftp> ");
|
|
int len = readline(cmd, sizeof(cmd));
|
|
if (len == 0) continue;
|
|
|
|
/* Check for local quit command */
|
|
if (strcmp(cmd, "quit") == 0 || strcmp(cmd, "exit") == 0 ||
|
|
strcmp(cmd, "bye") == 0) {
|
|
send_cmd(sockfd, "QUIT");
|
|
recv_response(sockfd);
|
|
puts("Goodbye.\n");
|
|
break;
|
|
}
|
|
|
|
/* Check for help */
|
|
if (strcmp(cmd, "help") == 0 || strcmp(cmd, "?") == 0) {
|
|
puts("ClaudeOS FTP Client\n");
|
|
puts("Send raw FTP commands:\n");
|
|
puts(" USER <username> - specify username\n");
|
|
puts(" PASS <password> - specify password\n");
|
|
puts(" PWD - print working directory\n");
|
|
puts(" CWD <path> - change directory\n");
|
|
puts(" LIST - list files (control channel only)\n");
|
|
puts(" SYST - show system type\n");
|
|
puts(" STAT - show server status\n");
|
|
puts(" QUIT - disconnect\n");
|
|
puts(" quit/exit/bye - disconnect and exit\n");
|
|
continue;
|
|
}
|
|
|
|
/* Send the command to server */
|
|
if (send_cmd(sockfd, cmd) < 0) {
|
|
puts("ftp: send failed\n");
|
|
break;
|
|
}
|
|
|
|
/* Receive response */
|
|
code = recv_response(sockfd);
|
|
if (code < 0) {
|
|
puts("ftp: connection lost\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|