FTP传输项目

最新推荐文章于 2024-05-29 13:53:18 发布
最新推荐文章于 2024-05-29 13:53:18 发布
阅读量113 收藏
点赞数
分类专栏： 所学实现 文章标签： linux 网络 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52150001/article/details/130728215
版权

FTP传输项目

衔接Linux–网络编程，使用socke套接字实现。

此项目包含文件编程、进程、网络编程。

要点巩固：

​ Server

  1. socket():返回一个网络描述符（类似open返回文件描述符）

  2. bind() :为套接字添加信息（IP地址和端口号）

  3. listen():监听网络连接

  4. accept():监听到有客户端接入，接受一个连接

  5. write() & read():数据交互

  6. close():关闭套接字，断开连接

    Client

    1. socket()
    2. connect()
    3. write() & read()
    4. close()

一、实现客服端退出（quit）功能

fflush函数

fflush_百度百科 (baidu.com)

函数名: fflush
    //fflush是一个在C语言标准输入输出库中的函数，功能是冲洗流中的信息，该函数通常用于处理磁盘文件。fflush()会强迫将缓冲区内的数据写回参数stream 指定的文件中。
功 能: 清除读写缓冲区，在需要立即把输出缓冲区的数据进行物理写入时
头文件：stdio.h
原型:int fflush(FILE *stream)
其中stream是要冲洗的流
返回值：
   	如果成功刷新,fflush返回0。指定的流没有缓冲区或者只读打开时也返回0值。返回EOF指出一个错误。
注意:如果fflush返回EOF,数据可能由于写错误已经丢失。当设置一个重要错误处理器时,最安全的是用setvbuf函数关闭缓冲或者使用低级I/0例程,如open、close和write来代替流I/O函数。
其他用法：
fflush(stdin)刷新标准输入缓冲区，把输入缓冲区里的东西丢弃[非标准]
fflush(stdout)刷新标准输出缓冲区，把输出缓冲区里的东西打印到标准输出设备上
message.h
#define QUIT 0 // 客服端退出

struct Message
{
	int type;
	char cmd[128];
	char data[1024];
	
};
sever.c
#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "message.h"
int get_cmd(char *cmd)
{
	if(!strcmp("quit",cmd))		return QUIT;
	return -1;
}

void message_handler(struct Message message,int fd)
{

	printf("cmd:%s\n",message.cmd);
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case QUIT:
			printf("client quit\n");
			exit(-1);
			
	}
}
int main(int argc,char **argv)
{
	int s_fd;
	int c_fd;
	int c_addrlen;
	int nread;
    char readbuf[1024] = {0};
	struct Message message;
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
    memset(&readbuf,0,sizeof(readbuf));
	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//1.socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.bind

	if(bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in)) == -1){
		perror("bind");
		exit(-1);
	}
	//3.listen
	if(listen(s_fd,5) == -1){
		perror("listen");
		exit(-1);
	}
	//4.accept
	c_addrlen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_addrlen);
		if(c_fd == -1){
			perror("accept");
			exit(-1);
		}
		printf("I get your IP :%s\n",inet_ntoa(c_addr.sin_addr));
		//5.write/read

		if(fork() == 0){
			while(1){
				memset(&readbuf,0,sizeof(readbuf));
				nread = read(c_fd,&message,sizeof(message));
				if(nread == -1 ){ //read失败时
					perror("read");
				}else if(nread == 0){ //read为空时
					printf("client out\n");
					break;
				}else if(nread > 0){ //read有数据时
					message_handler(message,c_fd);
				}
			}
		}

	}
	//6.close
	close(s_fd);
	close(c_fd);
	return 0;
}
client.c
#include <stdio.h>
#include "message.h"
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
int get_cmd(char *cmd)
{
        if(!strcmp("quit",cmd))         return QUIT;
       
        return -1;
}
void server_message(struct Message message ,int fd)
{
	int nread;
	struct Message getMessage;
	int newFileFd;
	nread = read(fd,&getMessage,sizeof(getMessage));
	if(nread == -1){		
		printf("read cmd failed!\n");
		exit(-1);
	}else{
		printf("------------------\n");
		printf("%s\n",getMessage.data);
		printf("------------------\n");
		printf(">>");
		fflush(stdout);		//清除读写缓冲区
	}
	
}
int  cmd_handler(struct Message message,int fd)
{
	int ret = get_cmd(message.cmd);
	switch(ret)
	{

		case QUIT:
			write(fd,&message,sizeof(message));
			exit(-1);		
	}
	return ret;

	
}
int main(int argc,char **argv)
{
	int c_fd;
	int c_addrlen;
	int nread;
	struct Message message;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//1.socket
	c_fd = socket(AF_INET,SOCK_STREAM,0);
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){ //连接服务器
		perror("connect");
		exit(-1);
	}
	printf("wait connect...\n");
	//3.write/read
	while(1){
	
		memset(&message.cmd,0,sizeof(sendmess.cmd));
		printf(">>"); 
		gets(message.cmd);				//获取命令
        
		
		int ret = cmd_handler(message,c_fd);
		if(ret == -1){
			printf("please input right cmd\n");
			printf(">>");
			fflush(stdout);		//清除读写缓冲区
			continue;
		}
		server_message(message,c_fd);
	}
	//4.close
	close(c_fd);
	return 0;
}

运行结果：
在这里插入图片描述

二、实现服务端ls、pwd，客户端ls

message.h
#define LS     0	//查看服务器文件
#define CD     1	//进入服务器目录
#define PWD    2	//查看服务器文件路径

#define IFGO   3
#define LLS    4	//查看客户端文件
#define QUIT   5	//客服端退出

struct Message
{
	int type;
	char cmd[128];
	char data[1024];
	
};
server.c
#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "message.h"
int get_cmd(char *cmd)
{
	if(!strcmp("ls",cmd))		return LS;
	if(!strcmp("pwd",cmd))		return PWD;
	if(!strcmp("quit",cmd))		return QUIT;
	return -1;
}

void message_handler(struct Message message,int fd)
{
	char data[1024] = {0};
	char *file = NULL;
	int fdfile;
	printf("cmd:%s\n",message.cmd);
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case LS:		//查看服务器文件
		case PWD:		//查看服务器文件路径
			message.type = 0;
			FILE *r = popen(message.cmd,"r");	//Linux系统编程--进程  13.popen函数有讲
			fread(message.data,sizeof(message.data),1,r);	//将r内容读到message.data
			write(fd,&message,sizeof(message));				//将整个结构体发给客服端
			break;
		case QUIT:
			printf("client quit\n");		
			exit(-1);
			
	}
}
int main(int argc,char **argv)
{
	int s_fd;
	int c_fd;
	int c_addrlen;
	int nread;
    char readbuf[1024] = {0};
	struct Message message;
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
    memset(&readbuf,0,sizeof(readbuf));
	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//1.socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.bind

	if(bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in)) == -1){
		perror("bind");
		exit(-1);
	}
	//3.listen
	if(listen(s_fd,5) == -1){
		perror("listen");
		exit(-1);
	}
	//4.accept
	c_addrlen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_addrlen);
		if(c_fd == -1){
			perror("accept");
			exit(-1);
		}
		printf("I get your IP :%s\n",inet_ntoa(c_addr.sin_addr));
		//5.write/read
		
		if(fork() == 0){	//有新接入时不断创建子进程
			while(1){
				memset(&readbuf,0,sizeof(readbuf));
				nread = read(c_fd,&message,sizeof(message));
				if(nread == -1 ){
					perror("read");
				}else if(nread == 0){
					printf("client out\n");
					break;
				}else if(nread > 0){
					message_handler(message,c_fd);
				}
			}
		}

	}
	//6.close
	close(s_fd);
	close(c_fd);
	return 0;
}
client.c
#include <stdio.h>
#include "message.h"
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
int get_cmd(char *cmd)
{
        if(!strcmp("ls",cmd))           return LS;
		if(!strcmp("lls",cmd))			return LLS;
        if(!strcmp("pwd",cmd))          return PWD;
        if(!strcmp("quit",cmd))         return QUIT;
        return -1;
}
void server_message(struct Message message ,int fd)
{
	int nread;
	struct Message getMessage;
	int newFileFd;
	nread = read(fd,&getMessage,sizeof(getMessage));
	if(nread == -1){
		printf("read cmd failed!\n");
		exit(-1);
	}else{
		printf("------------------\n");
		printf("%s\n",getMessage.data);
		printf("------------------\n");
		printf(">>");
		fflush(stdout);
	}
	
}
int  cmd_handler(struct Message message,int fd)
{
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case LS:	//查看服务端文件
		case PWD:	//查看服务端路径
			message.type = 0;
			write(fd,&message,sizeof(message));		
            break;
		case LLS:	//查看客户端文件
            system("ls");							
			break;
		case QUIT:	//客户端退出
            write(fd,&message,sizeof(message));
			exit(-1);
			break;		
	}
	return ret;

	
}
int main(int argc,char **argv)
{
	int c_fd;
	int c_addrlen;
	int nread;
    int mark = 0;
	struct Message message;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//1.socket
	c_fd = socket(AF_INET,SOCK_STREAM,0);
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
		perror("connect");
		exit(-1);
	}
	printf("wait connect...\n");
	//3.write/read
	while(1){
	
		memset(&message.cmd,0,sizeof(message.cmd));
		if(mark == 0)	printf(">>");
		gets(message.cmd);		//等待用户输入命令
		
		
		int ret = cmd_handler(message,c_fd);
        	if(strlen(message.cmd) == 0){
			if(mark == 1){
				printf(">>");
			}
			continue;
		}
		mark = 1;
		if(ret > IFGO){
			printf(">>");
			fflush(stdout);
			continue;
		} 		
 
		if(ret == -1){
			printf("please input right cmd\n");
			printf(">>");
			fflush(stdout);
			continue;
		}
		server_message(message,c_fd);
	}
	//4.close
	close(c_fd);
	return 0;
}

运行结果：
在这里插入图片描述

三、实现服务端、客户端cd操作

不能使用system("cd")来操作，system内核源码是通过fork函数来实现的，在此不实用

使用chdir函数实现cd操作

chdir函数

chdir_百度百科 (baidu.com)

chdir 是C语言中的一个系统调用函数（同cd），用于改变当前工作目录，其参数为Path 目标目录，可以是绝对目录或相对目录。

chdir函数原型

#include <unistd.h>
int chdir(const char *path);

chdir_demo.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{

    system("pwd");
    chdir("..");//返回上一级目录
    system("pwd");

    return 0;


        return 0;
}

输出结果：
在这里插入图片描述

getcwd函数

getcwd_百度百科 (baidu.com)

getcwd()会将当前工作目录的绝对路径复制到参数buffer所指的内存空间中,参数maxlen为buffer的空间大小。

功能：获取当前工作目录

#include <unistd.h>
char *getcwd( char *buffer, int maxlen );
/*
参数说明：getcwd()会将当前工作目录的绝对路径复制到参数buffer所指的内存空间中,参数maxlen为buffer的空间大小。
返 回 值：成功则返回当前工作目录，失败返回 FALSE。
*/

getcwd_demo.c

#include <stdio.h>
#include <unistd.h>

int main()
{

    char temp[4096] = {0};

    getcwd(temp, sizeof(temp));//获得当前工作目录的绝对路径，存放到temp当中
    printf("%s\n",temp);//输出当前绝对路径
    printf("================================\n");

    chdir("..");//返回上一级目录
    getcwd(tmp, sizeof(temp));//获得上一级工作目录的绝对路径，存放到temp当中
    printf("%s\n",temp);//输出上一级工作目录的绝对路径

        return 0;
}

输出结果：
在这里插入图片描述

message.h
#define LS     0
#define CD     1
#define PWD    2

#define IFGO   3

#define GET    4
#define NEW    5	//客户端 cd功能
#define LLS    6
#define PUT    7
#define QUIT   8

struct Message
{
        int type;
        char cmd[128];
        char data[1024];

};
server.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "message.h"
int get_cmd(char *cmd)
{
	if(!strcmp("ls",cmd))		return LS;	
	if(!strcmp("pwd",cmd))		return PWD;
	if(!strcmp("quit",cmd))		return QUIT;
	if(strstr(cmd,"cd")!=NULL)	return CD;
	return 100;
}
char *getDesDir(char *cmsg)
{
	char *p;
	p = strtok(cmsg," ");
	p = strtok(NULL," ");
	printf("%s\n",p);
	return p;
}
void message_handler(struct Message message,int fd)
{
	char data[1024] = {0};
	char systemData[64] = ".. ~";
	int ifhave6;
	char *file = NULL;
	int fdfile;
	printf("cmd:%s\n",message.cmd);
	int ret = get_cmd(message.cmd);
	printf("ret :%d\n",ret);
	switch(ret)
	{
		case LS:
		case PWD:
			message.type = 0;
			FILE *r = popen(message.cmd,"r");
			fread(message.data,sizeof(message.data),1,r);
			write(fd,&message,sizeof(message));
			break;
		case CD:
			message.type = 1;
			char *dir = getDesDir(message.cmd);
			chdir(dir);									
			getcwd(message.data,sizeof(message.data));  //获得当前目录绝对路径
			write(fd,&message,sizeof(message));			//将路径发送给客户端
			break;	
		case QUIT:
			printf("client quit\n");
			exit(-1);
			
	}
}
int main(int argc,char **argv)
{
	int s_fd;
	int c_fd;
	int c_addrlen;
	int nread;
	char readbuf[1024] = {0};
	struct Message message;
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&readbuf,0,sizeof(readbuf));
	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//1.socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.bind

	if(bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in)) == -1){
		perror("bind");
		exit(-1);
	}
	//3.listen
	if(listen(s_fd,5) == -1){
		perror("listen");
		exit(-1);
	}
	//4.accept
	c_addrlen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_addrlen);
		if(c_fd == -1){
			perror("accept");
			exit(-1);
		}
		printf("I get your IP :%s\n",inet_ntoa(c_addr.sin_addr));
		//5.write/read

		if(fork() == 0){
			while(1){
				memset(&readbuf,0,sizeof(readbuf));
				nread = read(c_fd,&message,sizeof(message));
				if(nread == -1 ){
					perror("read");
				}else if(nread == 0){
					printf("client out\n");
					break;
				}else if(nread > 0){
					message_handler(message,c_fd);
				}
			}
		}

	}
	//6.close
	close(s_fd);
	close(c_fd);
	return 0;
}
client.c
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "message.h"
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
char *getDir(char *msg)
{
        char *p;
        p = strtok(msg," ");
        p = strtok(NULL," ");
	printf("%s\n",p);
        return p;
}


int get_cmd(char *cmd)
{
        if(!strcmp("ls",cmd))           return LS;
		if(!strcmp("lls",cmd))			return LLS;
        if(!strcmp("pwd",cmd))          return PWD;
        if(!strcmp("quit",cmd))         return QUIT;
		if(strstr(cmd,"cd")!=NULL)      return CD;
		if(strstr(cmd,"new")!=NULL)     return NEW;

        return -1;
}
int  cmd_handler(struct Message message,int fd)
{
	int fdfile;
	char *dir = NULL;
	char buf[32];
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case LS:
		case CD:
		case PWD:
			message.type = 0;
			write(fd,&message,sizeof(message));
			break;
		case LLS:
			system("ls");
			break;
		case NEW:
			dir = getDir(message.cmd);
			chdir(dir);
			system("pwd");
			break;
		case QUIT:
			write(fd,&message,sizeof(message));
			exit(-1);
			break;		
	}
	return ret;

	
}
void server_message(struct Message message ,int c_fd)
{
	int nread;
	struct Message getMessage;
	int newFileFd;
	nread = read(c_fd,&getMessage,sizeof(getMessage));
	//printf("getmessage:%d\n",getMessage.type);
	if(nread == -1){
		printf("read cmd failed!\n");
		exit(-1);
	}else if(getMessage.type == DOFILE){
		char *p = getDir(getMessage.cmd);
		newFileFd = open(p,O_RDWR|O_CREAT,0600);
		write(newFileFd,&getMessage.data,strlen(getMessage.data));
		printf(">>");
		fflush(stdout);
		
	}else {
		printf("------------------\n");
		printf("%s\n",getMessage.data);
		printf("------------------\n");
		printf(">>");
		fflush(stdout);
	}
	
}
int main(int argc,char **argv)
{
	int c_fd;
	int c_addrlen;
	int nread;
	int mark = 0;
	struct Message message;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//1.socket
	c_fd = socket(AF_INET,SOCK_STREAM,0);
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
		perror("connect");
		exit(-1);
	}
	printf("wait connect...\n");
	//3.write/read
	while(1){
	
		memset(&message.cmd,0,sizeof(message.cmd));
		if(mark == 0)	printf(">>");
		gets(message.cmd);
		
		if(strlen(message.cmd) == 0){
			if(mark == 1){
				printf(">>");
			}
			continue;
		}
		mark = 1;
		
		int ret = cmd_handler(message,c_fd);
		if(ret > IFGO){
			printf(">>");
			fflush(stdout);
			continue;
		}
		if(ret == -1){
			printf("please input right cmd\n");
			printf(">>");
			fflush(stdout);
			continue;
		}
		//printf("inter server\n");
		server_message(message,c_fd);
	}
	//4.close
	close(c_fd);
	return 0;
}

运行结果：
在这里插入图片描述

四、实现面对服务端上传（put）文件和获取(get)文件

message.h
#define LS     0
#define CD     1
#define PWD    2
#define GET    3
#define IFGO   4
#define NEW    5
#define LLS    6
#define PUT    7
#define QUIT   8
#define DOFILE 9

struct Message
{
	int type;
	char cmd[128];
	char data[1024];
	
};
server.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "message.h"
int get_cmd(char *cmd)
{
	if(!strcmp("ls",cmd))		return LS;	
	if(!strcmp("pwd",cmd))		return PWD;
	if(!strcmp("quit",cmd))		return QUIT;
	if(strstr(cmd,"cd")!=NULL)	return CD;
	if(strstr(cmd,"get")!=NULL)	return GET;
	if(strstr(cmd,"put")!=NULL)	return PUT;
	return 100;
}
char *getDesDir(char *cmsg)
{
	char *p;
	p = strtok(cmsg," ");
	p = strtok(NULL," ");
	printf("%s\n",p);
	return p;
}
void message_handler(struct Message message,int fd)
{
	char data[1024] = {0};
	char *file = NULL;
	int fdfile;
	printf("cmd:%s\n",message.cmd);
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case LS:
		case PWD:
			message.type = 0;
			FILE *r = popen(message.cmd,"r");
			fread(message.data,sizeof(message.data),1,r);
			write(fd,&message,sizeof(message));
			break;
		case CD:
			message.type = 1;
			printf("this is cd\n");
			char *dir = getDesDir(message.cmd);
			printf("dir:%s\n",dir);
			chdir(dir);
			getcwd(message.data,sizeof(message.data));
			write(fd,&message,sizeof(message));
			break;
		case GET:
			file = getDesDir(message.cmd);
			if(access(file,F_OK) == -1){
				strcpy(message.data,"no this file!");
				printf("no file\n");
				write(fd,&message,sizeof(message));
			}else{
				message.type = DOFILE;
				fdfile = open(file,O_RDWR);
				read(fdfile,data,sizeof(data));
				close(fdfile);
				strcpy(message.data,data);
				write(fd,&message,sizeof(message));
			}
			break;
		case PUT:
			fdfile = open(getDesDir(message.cmd),O_RDWR|O_CREAT,0666);
			write(fdfile,&message.data,strlen(message.data));
			close(fdfile);
			break;
		case QUIT:
			printf("client quit\n");
			exit(-1);
			
	}
}
int main(int argc,char **argv)
{
	int s_fd;
	int c_fd;
	int c_addrlen;
	int nread;
	char readbuf[1024] = {0};
	struct Message message;
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&readbuf,0,sizeof(readbuf));
	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//1.socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.bind

	if(bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in)) == -1){
		perror("bind");
		exit(-1);
	}
	//3.listen
	if(listen(s_fd,5) == -1){
		perror("listen");
		exit(-1);
	}
	//4.accept
	c_addrlen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_addrlen);
		if(c_fd == -1){
			perror("accept");
			exit(-1);
		}
		printf("I get your IP :%s\n",inet_ntoa(c_addr.sin_addr));
		//5.write/read

		if(fork() == 0){
			while(1){
				memset(&readbuf,0,sizeof(readbuf));
				nread = read(c_fd,&message,sizeof(message));
				if(nread == -1 ){
					perror("read");
				}else if(nread == 0){
					printf("client out\n");
					break;
				}else if(nread > 0){
					message_handler(message,c_fd);
				}
			}
		}

	}
	//6.close
	close(s_fd);
	close(c_fd);
	return 0;
}
client3.c
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "message.h"
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
char *getDir(char *msg)
{
        char *p;
        p = strtok(msg," ");
        p = strtok(NULL," ");
	printf("%s\n",p);
        return p;
}


int get_cmd(char *cmd)
{
        if(!strcmp("ls",cmd))           return LS;
	if(!strcmp("lls",cmd))		return LLS;
        if(!strcmp("pwd",cmd))          return PWD;
        if(!strcmp("quit",cmd))         return QUIT;
	if(strstr(cmd,"cd")!=NULL)      return CD;
	if(strstr(cmd,"new")!=NULL)     return NEW;
        if(strstr(cmd,"get")!=NULL)     return GET;
        if(strstr(cmd,"put")!=NULL)     return PUT;

        return -1;
}
int  cmd_handler(struct Message message,int fd)
{
	int fdfile;
	char *dir = NULL;
	char buf[32];
	int ret = get_cmd(message.cmd);
	switch(ret)
	{
		case LS:
		case CD:
		case PWD:
			message.type = 0;
			write(fd,&message,sizeof(message));
			break;
		case LLS:
			system("ls");
			break;
		case NEW:
			dir = getDir(message.cmd);
			chdir(dir);
			system("pwd");
			break;
		case GET:
			message.type = 2;
			write(fd,&message,sizeof(message));
			break;
		case PUT:
			strcpy(buf,message.cmd);
			dir = getDir(buf);
			printf("cdir:%s\n",dir);	
			if(access(dir,F_OK) == -1){
				printf("%s not exsit\n",dir);
			}else{
				fdfile = open(dir,O_RDWR);
				memset(&message.data,0,sizeof(message.data));	//空间初始化，防止拷贝乱码
				read(fdfile,message.data,sizeof(message.data));
				printf("cput:%s\n",message.data);
				close(fdfile);
				write(fd,&message,sizeof(message));
			}
			break;
		case QUIT:
			write(fd,&message,sizeof(message));
			exit(-1);
			break;		
	}
	return ret;

	
}
void server_message(struct Message message ,int c_fd)
{
	int nread;
	struct Message getMessage;
	int newFileFd;
	nread = read(c_fd,&getMessage,sizeof(getMessage));
	printf("getmessage:%d\n",getMessage.type);
	if(nread == -1){
		printf("read cmd failed!\n");
		exit(-1);
	}else if(getMessage.type == DOFILE){
		char *p = getDir(message.cmd);
		newFileFd = open(p,O_RDWR|O_CREAT,0600);
		write(newFileFd,&getMessage.data,strlen(getMessage.data));
		printf(">>");
		fflush(stdout);
		
	}else {
		printf("------------------\n");
		printf("%s\n",getMessage.data);
		printf("------------------\n");
		printf(">>");
		fflush(stdout);
	}
	
}
int main(int argc,char **argv)
{
	int c_fd;
	int c_addrlen;
	int nread;
	int mark = 0;
	struct Message message;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//1.socket
	c_fd = socket(AF_INET,SOCK_STREAM,0);
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
		perror("connect");
		exit(-1);
	}
	printf("wait connect...\n");
	//3.write/read
	while(1){
	
		memset(&message.cmd,0,sizeof(message.cmd));
		if(mark == 0)	printf(">>");
		gets(message.cmd);
		
		if(strlen(message.cmd) == 0){
			if(mark == 1){
				printf(">>");
			}
			continue;
		}
		mark = 1;
		
		int ret = cmd_handler(message,c_fd);
		if(ret > IFGO){
			printf(">>");
			fflush(stdout);
			continue;
		}
		if(ret == -1){
			printf("please input right cmd\n");
			printf(">>");
			fflush(stdout);
			continue;
		}
		server_message(message,c_fd);
	}
	//4.close
	close(c_fd);
	return 0;
}

运行结果：
在这里插入图片描述

五、实现服务端、客户端删除文件

message.h
#define LS     0	//查看客户端文件
#define CD     1	//改变服务端目录
#define PWD    2	//查看服务端目录
#define GET    3	//从服务端获得文件
#define IFGO   4	//用于判断
#define NEW    5	//改变客户端目录
#define LLS    6	//查看客户端文件
#define PUT    7	//向服务端上传文件
#define QUIT   8	//客户端退出
#define DOFILE 9	//用于get判断
#define RM     10	//删除服务端文件
#define DEL    11	//删除客户端文件
struct Message
{
	int type;
	char cmd[128];
	char data[1024];
	
};
server.c
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "message.h"
int get_cmd(char *cmd)
{
	if(!strcmp("ls",cmd))		return LS;	
	if(!strcmp("pwd",cmd))		return PWD;
	if(!strcmp("quit",cmd))		return QUIT;
	if(strstr(cmd,"cd")!=NULL)	return CD;
	if(strstr(cmd,"get")!=NULL)	return GET;
	if(strstr(cmd,"put")!=NULL)	return PUT;
	if(strstr(cmd,"rm")!=NULL)	return RM;
	return 100;
}
char *getDesDir(char *cmsg)
{
	char *p;
	p = strtok(cmsg," ");
	p = strtok(NULL," ");
	printf("%s\n",p);
	return p;
}
void message_handler(struct Message message,int fd)
{
	char data[1024] = {0};
	char *file = NULL;
	int fdfile;
	char *rmfile = NULL;
	char rmFile[128] = {0};
	printf("cmd:%s\n",message.cmd);
	int ret = get_cmd(message.cmd);
	switch(ret)			//判断指令
	{
		case LS:		//查看客户端文件
		case PWD:		//查看服务端目录
			message.type = 0;
			FILE *r = popen(message.cmd,"r");	
			fread(message.data,sizeof(message.data),1,r);
			write(fd,&message,sizeof(message));
			break;
		case CD:		//改变服务端目录
			message.type = 1;
			char *dir = getDesDir(message.cmd);
			printf("dir:%s\n",dir);
			chdir(dir);
			getcwd(message.data,sizeof(message.data));
			write(fd,&message,sizeof(message));
			break;
		case GET:		//从服务端获得文件
			file = getDesDir(message.cmd);	//获得文件名
			if(access(file,F_OK) == -1){	//判断是否有该文件
				strcpy(message.data,"no this file!");
				printf("no file\n");
				write(fd,&message,sizeof(message));
			}else{
				message.type = DOFILE;		//设置标志
				fdfile = open(file,O_RDWR);	
				read(fdfile,data,sizeof(data));		//将文件内容读到data
				close(fdfile);
				strcpy(message.data,data);			//拷贝data的数据给结构体
				write(fd,&message,sizeof(message));	//将结构体发送给客户端
			}
			break;
		case PUT:		//向服务端上传文件
			fdfile = open(getDesDir(message.cmd),O_RDWR|O_CREAT,0666);		//服务端接收到指令，获得文件名，创建文件设置权限，可读可写
			write(fdfile,&message.data,strlen(message.data));				//将客户端发送的结构体中的数据，写入创建的文件，实现上传
			close(fdfile);
			break;
		case RM:		//删除服务端文件
			rmfile = getDesDir(message.cmd);
			sprintf(rmFile,"rm %s",rmfile);	
			system(rmFile);
			break;
		case QUIT:		//删除客户端文件
			printf("client quit\n");
			exit(-1);

	}
}
int main(int argc,char **argv)
{
	int s_fd;
	int c_fd;
	int c_addrlen;
	int nread;
	char readbuf[1024] = {0};
	struct Message message;
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&readbuf,0,sizeof(readbuf));
	memset(&s_addr,0,sizeof(struct sockaddr_in));
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//1.socket
	s_fd = socket(AF_INET,SOCK_STREAM,0);
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.bind

	if(bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in)) == -1){
		perror("bind");
		exit(-1);
	}
	//3.listen
	if(listen(s_fd,5) == -1){
		perror("listen");
		exit(-1);
	}
	//4.accept
	c_addrlen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&c_addrlen);
		if(c_fd == -1){
			perror("accept");
			exit(-1);
		}
		printf("I get your IP :%s\n",inet_ntoa(c_addr.sin_addr));
		//5.write/read

		if(fork() == 0){
			while(1){
				memset(&readbuf,0,sizeof(readbuf));
				nread = read(c_fd,&message,sizeof(message));
				if(nread == -1 ){
					perror("read");
				}else if(nread == 0){
					printf("client out\n");
					break;
				}else if(nread > 0){
					message_handler(message,c_fd);
				}
			}
		}

	}
	//6.close
	close(s_fd);
	close(c_fd);
	return 0;
}
client3.c
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "message.h"
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
//#include <linux/in.h>
#include <sys/types.h>
#include <sys/socket.h>
char *getDir(char *msg)		//分割指令
{	
	char *p;
	p = strtok(msg," ");
	p = strtok(NULL," ");
	printf("%s\n",p);
	return p;
}


int get_cmd(char *cmd)		//判断指令返回指令编号
{
	if(!strcmp("ls",cmd))           return LS;		//查看客户端文件
	if(!strcmp("lls",cmd))			return LLS;		//查看客户端文件
	if(!strcmp("pwd",cmd))          return PWD;		//查看服务端目录
	if(!strcmp("quit",cmd))         return QUIT;	//客户端退出
	if(strstr(cmd,"cd")!=NULL)      return CD;		//改变服务端目录
	if(strstr(cmd,"new")!=NULL)     return NEW;		//改变客户端目录
	if(strstr(cmd,"get")!=NULL)     return GET;		//改变客户端目录
	if(strstr(cmd,"put")!=NULL)     return PUT;		//向服务端上传文件
	if(strstr(cmd,"rm")!=NULL)      return RM;		//删除服务端文件 
	if(strstr(cmd,"del")!=NULL)		return DEL;		//删除客户端文件
	return -1;
}
int  cmd_handler(struct Message message,int fd)
{
	int fdfile;
	char *dir = NULL;
	char *rmfile = NULL;
	char rmFile[128] = {0};
	char buf[32];
	int ret = get_cmd(message.cmd);		//
	switch(ret)		//判断指令
	{
		case LS:
		case CD:
		case PWD:
			message.type = 0;
			write(fd,&message,sizeof(message));
			break;
		case LLS:
			system("ls");
			break;
		case NEW:
			dir = getDir(message.cmd);
			chdir(dir);
			system("pwd");
			break;
		case GET:
			message.type = 2;
			write(fd,&message,sizeof(message));
			break;
		case PUT:
			strcpy(buf,message.cmd);
			dir = getDir(buf);									//获得文件名
			printf("cdir:%s\n",dir);	
			if(access(dir,F_OK) == -1){							//判断文件是否存在
				printf("%s not exsit\n",dir);
			}else{
				fdfile = open(dir,O_RDWR);						//打开该文件，可读可写
				memset(&message.data,0,sizeof(message.data));	//读数据前先初始化空间，防止乱码
				read(fdfile,message.data,sizeof(message.data));	//将文件内容读到结构体中
				close(fdfile);									//关闭文件防止文件损坏
				write(fd,&message,sizeof(message));				//发送结构体给服务端
			}
			break;
		case RM:
			write(fd,&message,sizeof(message));
			break;	
		case DEL:
			rmfile = getDir(message.cmd);
			sprintf(rmFile,"rm %s",rmfile);
			system(rmFile);
			break;	
		case QUIT:
			write(fd,&message,sizeof(message));
			exit(-1);
			break;		
	}
	return ret;


}
void server_message(struct Message message ,int c_fd)		//接受服务端返回信息
{
	int nread;
	struct Message getMessage;
	int newFileFd;
	printf("1\n");
	nread = read(c_fd,&getMessage,sizeof(getMessage));
	printf("2\n");
	printf("getmessage:%d\n",getMessage.type);
	if(nread == -1){
		printf("read cmd failed!\n");
		exit(-1);
	}else if(getMessage.type == DOFILE){		//用于get指令
		char *p = getDir(message.cmd);			//分割指令，获得文件名
		newFileFd = open(p,O_RDWR|O_CREAT,0600);	//创建文件名
		write(newFileFd,&getMessage.data,strlen(getMessage.data));	//将服务端读取到的内容写入该文件
		printf(">>");
		fflush(stdout);

	}else {
		printf("------------------\n");
		printf("%s\n",getMessage.data);
		printf("------------------\n");
		printf(">>");
		fflush(stdout);
	}

}
int main(int argc,char **argv)
{
	int c_fd;
	int c_addrlen;
	int nread;
	int mark = 0;
	struct Message message;
	struct sockaddr_in c_addr;
	if(argc != 3){
		printf("please input right param\n");
		exit(-1);
	}
	memset(&c_addr,0,sizeof(struct sockaddr_in));
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//1.socket
	c_fd = socket(AF_INET,SOCK_STREAM,0);
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	//2.connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr_in)) == -1){
		perror("connect");
		exit(-1);
	}
	printf("wait connect...\n");
	//3.write/read
	while(1){

		memset(&message.cmd,0,sizeof(message.cmd));		//初始化指令空间
		if(mark == 0)	printf(">>");
		gets(message.cmd);

		if(strlen(message.cmd) == 0){
			if(mark == 1){
				printf(">>");
			}
			continue;
		}
		mark = 1;

		int ret = cmd_handler(message,c_fd);	//获得指令编号
		if(ret > IFGO){		//用于判断指令编号
			printf(">>");
			fflush(stdout);		//清除读写缓冲区
			continue;
		}
		if(ret == -1){
			printf("please input right cmd\n");
			printf(">>");
			fflush(stdout);			
			continue;
		}
		server_message(message,c_fd);
	}
	//4.close
	close(c_fd);
	return 0;
}

运行结果：

删除服务端文件：
在这里插入图片描述

删除客户端文件：
在这里插入图片描述

猪jio杆炖不耙丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux——FTP文件传输服务
m0_64292323的博客
06-26 1790
Linux操作系统提供了多种FTP（File Transfer Protocol）文件传输服务，包括常用的vsftpd和proftpdFTP（File Transfer Protocol）是一种常见的文件传输协议，用于在计算机之间传输文件。Linux操作系统中提供了多种FTP文件传输服务，可以通过这些服务在Linux系统上搭建FTP服务器，使其他计算机能够通过FTP协议访问文件。常见的Linux FTP服务有vsftpd、proftpd等，其中vsftpd是最常用的FTP服务之一。
JAVA实现FTP文件上传下载及FTP服务器搭建
Xunyinyiran的博客
11-25 2418
最近项目中需要到FTP服务器中下载文件，于是花了点时间研究了一下，网上查了很多资料，都没有很详细的FTP服务器的搭建教程，踩了很多坑，终于搞定了，因此在此记录分享，如有错误，欢迎大家指正，谢谢！FTP是一个专门进行文件管理的操作服务，一般来讲可以在任意的操作系统之中进行配置，但是如果考虑到简便性，一般来讲可以直接在Linux系统下进行安装。 FTP (File Transfer Protocol、文件传输协议）是TCP/IP协议中的一部分，属于应用层协议。
基于Linux的FTP文件传输项目（类似百度云）
weixin_47921928的博客
08-28 744
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录项目功能一、服务端1.定义命令宏2.命令转换3.服务端的网络编程4.实现LS，PWD功能5.实现GET功能6.实现PUT功能7.实现CD，QUIT功能二、客户端1.实现LS,PWD,CD,GET功能2.实现PUT功能3.实现LLS,LCD,QUIT功能打印服务端的数据整体项目代码总结 项目功能 显示服务端文件：ls 显示服务端路径：PWD 切换服务端目录：CD 获取服务端文件：GET 将客户端文件上传到服务端：PUT 显示客户端
项目名称：FTP文件传输服务器（Linux）
qq_51924918的博客
08-24 126
该项目基于FTP协议，致力于实现高效的文件传输和基本的文件管理功能，以满足日常文件传输和管理的需求。通过对FTP协议的改进，使文件传输更加便捷，同时提供了基本的文件管理功能。博客内容包括项目的背景、目标、结构、核心代码示例以及项目的未来发展方向。希望这个项目能够为用户提供更高效、便捷的文件传输和管理体验。
【Linux】简易ftp文件传输项目（云盘）
Apibro的博客
11-30 395
前言：这是对linux系统编程学习的总结，具体操作过程在代码里有注释。 二、Server 三、Client 四、项目结果 服务器运行，可以有多个客户端接入，如下： Server： Client： 最后谢谢阅读，笔者乃小白，如有错误之处还请指正。
FTP文件传输
风间琉璃的博客
10-09 452
项目场景： 提示：这里简述项目相关背景： 用于Ubuntu和Windows之间的文件传输 问题描述： 提示：这里描述项目中遇到的问题： 每次都在Lniux上在下文件不太方便，然后在网上突然看到这个应用，觉得挺有用，还操作简便 解决方案： 提示：这里填写该问题的具体解决方案： 1.开启 Ubuntu 下的 FTP 服务 (1)安装FTP sudo apt-get install vsftpd (2)修改配置 local_enable=YES write_enable=YES (3)重启FTP su
FTP服务器项目
kakaka666的博客
06-11 1825
本项目实现一个FTP服务器，通过FTP客户端(如FileZilla)来获取文件列表、下载、上传、删除文件等功能。用到了libevent网络事件库管理socket的连接加入线程池来并发的处理请求，应用创建型模式-工厂模式来管理FTP客户端的请求命令码去注册对象。Libevent的更多内容链接:libevent C++高并发网络编程FTP协议的更多内容链接:FTP协议详解工厂模式的更多内容链接:C++设计模式 - 创建型模式之工厂模式项目完整代码git仓库。
简单FTP传输服务项目
03-05
户端首先连接到FTP服务器的控制端口，然后打开一个随机的非特权端口（通常大于1024），并向服务器发送PORT命令，告知服务器使用这个端口进行数据传输。在被动模式下，FTP客户端向服务器发送PASV命令，要求服务器打开...
FTP异地传输文件项目
01-03
此项目使用的框架是jfina的框架，使用FTP传输技术，分为客户端和服务端，客户端使用到的技术有： 1、传输文件分隔 2、文件加密 3、定时传输 4、多线程传输 服务端使用到的技术有： 1、文件解密 2、MD5校验文件传输...
python实现ftp文件传输
12-22
最近做了一个简单的文件传输系统，基于ftp协议，使用python语言开发，虽然python里面已经有ftplib模块，可以很容易的实现ftp服务器。这次我使用的是socket实现client与ftp server之间的通讯和文件传输，client另起一...
ftp java 项目.zip
01-12
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
网编小项目：FTP文件传输服务器
08-24
该项目是一个FTP（文件传输协议）服务器，允许用户通过网络连接并在服务器和客户端之间传输文件。 项目旨在实现高效的文件传输，同时提供基本的文件管理功能。 支持多客户端 多线程并发。
FTP文件传输服务
qq_71164192的博客
06-30 1211
基于系统用户的FTP服务是指使用操作系统中已有的用户账户和密码来进行FTP服务的认证和管理。与虚拟用户管理相比，基于系统用户的FTP服务更简单和直接，因为它直接使用系统中已经存在的用户信息。启动FTP服务器并测试连接：完成配置后，可以启动FTP服务器并尝试使用系统用户的账户和密码进行连接和访问。配置FTP服务器的认证方式：在FTP服务器的配置文件中，可以指定认证方式为系统用户。配置其它FTP服务器参数：根据需求，可以配置FTP服务器的其它参数，如默认目录、用户权限、传输模式等。
FTP服务器项目的一些整理
缱绻的西格玛
03-12 3683
几个月前按照网上的教程写了一个FTP的服务器，现在回头整理一下里面的一些知识。 FTP简介 FTP是文件传输协议（File Transfer Protocol），工作在TCP/IP协议族的应用层，其传输层使用的是TCP协议，它是基于客户/服务器模式工作的（C/S架构），TCP/IP协议中，FTP标准命令TCP端口号为21，Port方式数据端口为20。 FTP的两种传输方式 FTP有两种传输
Ftp文件上传
mmqw1122的专栏
03-30 646
前段时间项目中用到的FTP文件上传，自己谢了一个基于FTPClient的FTP文件上传函数 用的到jar包的下载地址：commons-net-1.4.1.jar FTP文件上传过程中需要注意，FTP支持二级制和ASCII码的文件上传，需要根据需要指定上传类型（一般二进制的没什么问题），不然会出现上传文件大小不一致或者损坏的问题。 具体的实现： /** * FTPClient 上传文
Linux - 磁盘的分区和挂载
weixin_45735487的博客
05-27 757
逻辑分区只能在拓展分区上划分，编号5-15。拓展分区编号1-4，拓展分区不能格式化。rescue 恢复分区,对于误删的分区进行恢复,语法: rescue 起始 结束。rm 删除分区,后接要删除的分区编号。（L） 在主分区和拓展分区划分完之后，默认提示划分逻辑分区。n 进行磁盘分区，这里会默认MBR标签。（p） msdos下，会默认选择先划分主分区。
【Linux】升级GCC（版本9.3），补充：binutils
yannan20190313的博客
05-27 806
【Linux】升级GCC（版本9.3），补充：binutils
【Linux】中常见的重要指令（下）以及重要的几个热键
2401_84568462的博客
05-27 1192
find指令查找的文件不能当前路径下（可以这样理解：如果要查找当前路径下可以使用ls指令，就不麻烦find指令了），必须查找当前路径下的目录里的文件。1.能被打包压缩的一定是由多个文件组成的，打包压缩后将文件变为一个整体，在传递给其他用户时不容易缺失。.tar打包后缀 .gz压缩后缀 XXX.tar.gz ----->XXX.tgz。功能：在系统特定的路径下查找，及可以找到可执行程序，有可以找到手册，安装包和压缩包等。命令在目录结构中搜索文件，并执行指定的操作。功能：在指令路径下搜索指令文件。
IMX6Q基于linux4.1.15调试音频芯片tas2505
最新发布
qq_45147279的博客
05-29 165
获取时钟频率，因为我这边用的是外部晶振，不是使用CPU引脚MX6QDL_PAD_GPIO_0__CCM_CLKO1输出时钟的。如果上面of_match_table 的字符串跟设备树匹配上的话，接下来进入imx_tas2505_probe函数，这里我想说说设置ssi和audmux的方向问题，要么是由CPU输出BCLK,WCLK给音频芯片；tas2505_dai中的name变量名需要跟imx-tas2505.c中struct snd_soc_dai_link中的codec_dai_name变量名一样。
Java ftp传输
08-13
使用任何一种方式进行FTP传输时，都可以使用try-catch语句来捕获异常，以处理可能出现的连接错误、登录错误等异常情况。传输过程中，可以使用InputStream和OutputStream来进行文件的读取和写入操作。 总的来说，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值