linux下的简单文件服务器和客户端程序

最新推荐文章于 2023-07-07 09:13:08 发布
最新推荐文章于 2023-07-07 09:13:08 发布
阅读量4k 收藏 7
点赞数 2
分类专栏： linux网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012296503/article/details/51340015
版权

本文是我的一次作业，由于花了很多精力，记下来以后可能还会用到。代码部分是从老师那拷贝的，作业是实现代码中没有实现的put和delete命令对文件的操作。我对代码的理解都做了标注，有点乱，但阅读方便。本程序的命令要求

Dir/ls

后接字符串，列出服务器的某个目录的内容

Get

后接两个字符串，下载远程文件到本地目录

Delete

后接字符串，删除远程文件

Put

后接字符串，上传文件到远程目录


服务端和客户端都有一个user文件夹保存上传和下载的文件

本文全部代码和资源在http://download.csdn.net/detail/u012296503/9513179可下载


服务端代码server.c

#include	"unp.h"
#include <string.h>
#include <unistd.h>
#include <dirent.h>
void ftpserv(int sockfd);
void sig_chld(int signo);
ssize_t Readline2(int fd, void *ptr, size_t maxlen);
int main(int argc, char **argv)
{
	int					listenfd, connfd;
	pid_t				childpid;
    
    // 套接字地址结构的长度，一般为unit32_t
	socklen_t			clilen;
    
    // 网际套接字地址结构
	struct sockaddr_in	cliaddr, servaddr;
	void				sig_chld(int);
    
    // family是AF_INET表示地址族，type是SOCK_STREAM表示字节流套接字，protocol是0表示TCP传输协议
    // listenfd是套接字描述符
	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    
    /*
      以下代码，一直到listen函数，表示在待捆绑到该TCP套接字的网际接口套接字地址结构中填入
      通配地址（INADDR_ANY）和服务器的端口号为21000.捆绑通配地址是在告知系统，要是系统是
      多宿主机，我们将接受目的地址为任何本地接口的连接。在选择通配地址和指定端口号时，内核
      选择IP地址，进程指定端口号。
    
    */
    
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port        = htons(21000);
    
    // bind将一个本地协议地址赋予一个套接字，对于TCP服务器，就限定了该套接字只接受那些目的地为
    // 为这个IP地址的客户连接。
	Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
    
    // listen将该套接字装换成一个监听套接字，导致套接字从CLOSED状态转变成LISTEN状态。
	Listen(listenfd, LISTENQ);
    
    // 当SIGCHLD信号发生，函数sig_chld就会被调用
	Signal(SIGCHLD, sig_chld);	/* must call waitpid() */

	for ( ; ; )
	{
		clilen = sizeof(cliaddr);
        
		if ( (connfd = accept(listenfd, (SA *) &cliaddr, &clilen)) < 0)
		{
			if (errno == EINTR)
				continue;		/* back to for() */
			else
				err_sys("accept error");
		}

		if ( (childpid = Fork()) == 0)
		{	/* child process */
			Close(listenfd);	/* close listening socket */
			ftpserv(connfd);	/* process the request */
			exit(0);
		}
		Close(connfd);			/* parent closes connected socket */
	}
}



void ftpserv(int sockfd)
{
	ssize_t		n;
	char		buf[MAXLINE];
	char		sendline[MAXLINE];
	char wdpath[200];
    
    // char * getcwd(char * buffer, size_t size);会将当前的工作目录绝对路径复制到参数buffer所指的内存空间，
    // 参数size 为buffer的空间大小。获得当前目录
	
    if(getcwd(wdpath,200)==NULL)return ;
	strcat(wdpath,"/user");

	char dirname[1000];
	char dirlen[7];

	DIR *pdir;
	struct dirent *pent;
	if ((pdir = opendir(wdpath)) == NULL)
	{
		fprintf(stderr, "open dir failed.\n");
		return;
	}


again:
	while ( (n = Readline2(sockfd, buf, MAXLINE)) > 0)
	{
	    //Writen(sockfd, buf, n);
        fprintf(stderr,"n=%d\nbuf=%s",n,buf);
        
        /*作用于字符串buf，以包含在" \n"中的字符为分界符，将buf切分成一个个子串；
          cmd指向第一个子串。要想遍历子串需要一个循环
          while(cmd != NULL){
              printf("%s",cmd);
              cmd = strtok(NULL," \n"); //指针后移
          }
        */
	    char * cmd=strtok(buf," \n");

	    if( strcmp(cmd,"dir") ==0 || strcmp(cmd,"ls")==0)
	    {
	        char * pdirname=dirname;
	        int lines=0;

            // 从目录流中读取所有的目录项，并拷贝该目录结构的d_name字段
            while (1)
            {
                    pent = readdir(pdir);
                    if (pent == NULL) break;
                   // fprintf(stderr, "%5d %s\n",pent->d_ino, pent->d_name);
                    strcpy(pdirname,pent->d_name);
                    strcat(pdirname,"\r\n");
                    // 输出目录下的各个文件
                    fprintf(stderr, "%d %s",strlen(pdirname), pdirname);
                    lines++;
                    
                    pdirname += strlen(pent->d_name)+2;

            }
            *pdirname=0;
            // 将lines打印到字符串中
            sprintf(dirlen,"%d\n",lines);
            fprintf(stderr,"lines %d\n",lines);
            
            // 将dirlen写入套接字，以便客户端可以读取,此处写入行数
            Writen(sockfd, dirlen, strlen(dirlen));
            
            // 将目录中的文件名写入套接字中，以便客户端读取
            Writen(sockfd,dirname,strlen(dirname));
            
            // 目录项归起始位置，以便下次dir命令重新读取目录项。
            rewinddir(pdir);
	    }
	    else if(strcmp(cmd,"get")==0)
	    {

	        char filename[100];
            // 拼接目录
            strcpy(filename,wdpath);
            strcat(filename,"/");
            
            // strtok(NULL," \n")是get后面的文件名
            strcat(filename, strtok(NULL," \n"));
            FILE *fp=0;

            if((fp=fopen(filename,"rb"))==NULL)
            {
                fprintf(stderr,"failed open file %s",filename);
                return;
            }
            fprintf(stderr, "open file %s.\n",filename);

            long filelen;
            
            /*
                定义函数 int fseek(FILE * stream,long offset,int whence);
                函数说明 fseek()用来移动文件流的读写位置。参数stream为已打开的文件指针，参数offset为根据参数whence来移动读写位置的位移数。
                参数 whence为下列其中一种:
                SEEK_SET从距文件开头offset位移量为新的读写位置。SEEK_CUR 以目前的读写位置往后增加offset个位移量。
                SEEK_END将读写位置指向文件尾后再增加offset个位移量。
                当whence值为SEEK_CUR 或SEEK_END时，参数offset允许负值的出现。
            
            */
            fseek(fp,0,SEEK_END);
            
            /*
                定义函数 long ftell(FILE * stream);
                函数说明 ftell()用来取得文件流目前的读写位置。参数stream为已打开的文件指针。
                返回值 当调用成功时则返回目前的读写位置，若有错误则返回-1，errno会存放错误代码。
                错误代码 EBADF 参数stream无效或可移动读写位置的文件流。
            
            */
            filelen=ftell(fp);
            // rewind()用来把文件流的读写位置移至文件开头
            rewind(fp);
            char flen[7];
            sprintf(flen,"%d\n",(int)filelen);
            fprintf(stderr,"filesize %s\n",flen);
            
            // 服务器端算出文件的大小，并写入套接字以供客户端读取
            Writen(sockfd, flen, strlen(flen));
            // 同时显示出来文件的大小 
            fprintf(stderr, "sent filesize=%s",flen);

            long left=filelen;
            
            
            
            /*
            .一般调用形式 
              fread(buffer,size,count,fp); 
              fwrite(buffer,size,count,fp); 
             说明 
              （1）buffer：是一个指针，对fread来说，它是读入数据的存放地址。对fwrite来说，是要输出数据的地址。 
              （2）size：要读写的字节数； 
              （3）count:要进行读写多少个size字节的数据项； 
              （4）fp:文件型指针。 
            
            
            */
            
            // 如果文件大小大于MAXLINE就分次读，然后写入套接字。
            while(left>MAXLINE)
            {
                fread(sendline,MAXLINE,1,fp);
                Writen(sockfd, sendline, MAXLINE);
                left-=MAXLINE;
            }
            
            // 对于剩下的部分再处理
            if(left<=MAXLINE)
            {
                fread(sendline,left,1,fp);
                Writen(sockfd, sendline, left);
            }

            fprintf(stderr, "file sent done.\n");
            fclose(fp);




        } /**/
	   else if(strcmp(cmd,"put")==0){
            if(Readline2(sockfd,recvline,MAXLINE) == 0){
                err_quit("str_cli: client terminated prematurely");
            }
            int bytes = atoi(recvline);
            fprintf(stderr,"file length = %d.\n",bytes);
            int left = bytes;
            FILE *fp = 0;
            if(left > 0){
                char filename[100];
                strcpy(filename,wdpath);
                strcat(filename,"/");
                strcat(filename,strtok(NULL," \n"));
                if((fp = fopen(filename,"wb")) == NULL){
                    fprintf(stderr,"failed open file %s",filename);
                    return;
                }

                fprintf(stderr,"file create: %s.\n",filename);

            }

            while(left > MAXLINE){
                    Readn(sockfd,recvline,MAXLINE);
                    left -= MAXLINE;
                    fwrite(recvline,MAXLINE,1,fp);
            }
            if(left <= MAXLINE){

                Readn(sockfd,recvline,left);
                fwrite(recvline,left,1,fp);
            }

            fprintf(stderr,"file writen done.\n");
            fclose(fp);




        }
	    else if(strcmp(cmd,"delete")==0){
            char filename[100];
            char name[30];
            strcpy(filename,wdpath);
            strcat(filename,"/");

            strcat(filename,strtok(NULL," \n"));
            printf("filename is %s\n",filename);
            sprintf(name,"%s\n",filename);
            Writen(sockfd,name,strlen(name));
            if(remove(filename) == 0){
                fprintf(stderr,"file delete successfully.\n");

            }else{
                fprintf(stderr,"file don't exist.\n");
            }


        }


        if (n < 0 && errno == EINTR)
            goto again;
        else if (n < 0)
            err_sys(" read error");
        //closedir(pdir);

	}
	fprintf(stderr,"n=%d\nbuf=%s",n,buf);


}

void sig_chld(int signo)
{
	pid_t	pid;
	int		stat;

	while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0)
		printf("child %d terminated\n", pid);
	return;
}

ssize_t
readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t	n, rc;
	char	c, *ptr;

	ptr = vptr;
	for (n = 1; n < maxlen; n++) {
again:
		if ( (rc = read(fd, &c, 1)) == 1) {
			*ptr++ = c;
			if (c == '\n')
				break;	/* newline is stored, like fgets() */
		} else if (rc == 0) {
			*ptr = 0;
			return(n - 1);	/* EOF, n - 1 bytes were read */
		} else {
			if (errno == EINTR)
				goto again;
			return(-1);		/* error, errno set by read() */
		}
	}

	*ptr = 0;	/* null terminate like fgets() */
	return(n);
}
/* end readline */

ssize_t
Readline2(int fd, void *ptr, size_t maxlen)
{
	ssize_t		n;

	if ( (n = readline(fd, ptr, maxlen)) < 0)
		err_sys("readline error");
	return(n);
}




客户端client.c

#include <stdio.h>
#include <stdlib.h>
#include	"unp.h"
void ftp_cli(FILE *fp, int sockfd);
ssize_t Readline2(int fd, void *ptr, size_t maxlen);
int main(int argc, char **argv)
{
	int					sockfd;
    
    // 网际套接字地址结构
	struct sockaddr_in	servaddr;
    
	if (argc != 2) 	err_quit("usage: tcpcli <IPaddress>");
    
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(21000);
    // 将IP地址从数值形式转化为表达式形式
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
    // 调用connect函数是激发TCP的三路握手过程
	Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
	ftp_cli(stdin, sockfd);		/* do it all */
	exit(0);
}


void ftp_cli(FILE *fp, int sockfd)
{
	char sendline[MAXLINE], recvline[MAXLINE];
	char cmd [MAXLINE];

    // 获得当前目录
	char wdpath[200];
	if(getcwd(wdpath,200)==NULL)return ;
	strcat(wdpath,"/user");

	for ( ; ; )
	{
	    fprintf(stderr, "myftpclient-->");
        
        // 使用fputs和fgets从文件指针或者标准输入输出设备读写行数据。
        if (Fgets(sendline, MAXLINE, fp) == NULL) return;
		else fputs(sendline,stdout);
		strcpy(cmd,sendline);
		//int i;
		//for(i=0;i<strlen();i++)
		//fprintf(stderr,"%d\n",(int)(sendline[i]));
		char * pcmd=strtok(cmd," \n");
		if(strcmp(pcmd,"dir")==0||strcmp(pcmd,"ls")==0)
		{
           // 将输入的字符串序列写入套接字，以便在服务器端读取
           Writen(sockfd, sendline, strlen(sendline));
           
           // 从服务器读取行数在recvline中
		    if (Readline2(sockfd, recvline, MAXLINE) == 0)
				err_quit("str_cli: server terminated prematurely");
            // 将字符串转化为整数
            int lines=atoi(recvline);
            int i;
			for(i=0;i<lines;i++)
			{
			    Readline2(sockfd, recvline, MAXLINE);
			    fprintf(stderr,recvline);
			}
        }
        else if(strcmp(pcmd,"get")==0)
		{
            Writen(sockfd, sendline, strlen(sendline));
		    if (Readline2(sockfd, recvline, MAXLINE) == 0)
				err_quit("str_cli: server terminated prematurely");
            int bytes=atoi(recvline);
            fprintf(stderr, "file length = %d.\n",bytes); 
            int left=bytes;
            FILE *fp=0;
            if(left>0)
            {
                char filename[100];
                strcpy(filename,wdpath);
                strcat(filename,"/");
                // strtok(NULL," \n")是get后面的文件名
                strcat(filename, strtok(NULL," \n"));
                if((fp=fopen(filename,"wb"))==NULL)
                {
                    fprintf(stderr,"failed open file %s",filename);
                    return;
                }
                // 打印出文件路径
                fprintf(stderr, "file create: %s.\n",filename);
            }
            // 从套接字中读出数据然后写入文件中
            while(left>MAXLINE)
            {
                Readn(sockfd, recvline, MAXLINE);
                left-=MAXLINE;
                fwrite(recvline,MAXLINE,1,fp);
            }
            if(left<=MAXLINE)
            {
                Readn(sockfd, recvline, left);
			    //fprintf(stderr,recvline);
			    fwrite(recvline,left,1,fp);
            }
            fprintf(stderr, "file writen done.\n");
            fclose(fp);
        }
        else if(strcmp(pcmd,"quit")==0){
		    fprintf(stderr, "See you!.\n");
		    return;
	}<pre name="code" class="plain"><span style="white-space:pre">	</span>else if(strcmp(pcmd,"delete")==0){
		    Writen(sockfd,sendline,strlen(sendline));

            if (Readline2(sockfd, recvline, MAXLINE) == 0){
				err_quit("str_cli: server terminated prematurely");
            }else
                fprintf(stderr,"file %s delete successfully.\n",recvline);

        }else if(strcmp(pcmd,"put") == 0){

            Writen(sockfd, sendline, strlen(sendline));
            char filename[100];
            strcpy(filename,wdpath);
            strcat(filename,"/");

            strcat(filename,strtok(NULL," \n"));
            FILE *fp = 0;
            if((fp = fopen(filename,"rb")) == NULL){
                fprintf(stderr,"failed open file %s",filename);
                return;
            }
            fprintf(stderr,"open file %s.\n",filename);

            long filelen;

            fseek(fp,0,SEEK_END);
            filelen = ftell(fp);
            rewind(fp);
            char flen[7];
            sprintf(flen,"%d\n",(int)filelen);
            fprintf(stderr,"filesize %s\n",flen);

            Writen(sockfd,flen,strlen(flen));
            fprintf(stderr,"sent filesize=%s",flen);
            long left = filelen;

            while(left > MAXLINE){

                    fread(sendline,MAXLINE,1,fp);
                    Writen(sockfd,sendline,MAXLINE);
                    left -= MAXLINE;
            }

            if(left <= MAXLINE){

                fread(sendline,left,1,fp);
                Writen(sockfd,sendline,left);

            }

            fprintf(stderr,"file send done.\n");

            fclose(fp);


        }else{
            fprintf(stderr, "usage:cmd [args].\ncmd=\tdir\tls\tget\tquit\n");
        }


	}
}

ssize_t
readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t	n, rc;
	char	c, *ptr;

	ptr = vptr;
	for (n = 1; n < maxlen; n++) {
again:
		if ( (rc = read(fd, &c, 1)) == 1) {
			*ptr++ = c;
			if (c == '\n')
				break;	/* newline is stored, like fgets() */
		} else if (rc == 0) {
			*ptr = 0;
			return(n - 1);	/* EOF, n - 1 bytes were read */
		} else {
			if (errno == EINTR)
				goto again;
			return(-1);		/* error, errno set by read() */
		}
	}

	*ptr = 0;	/* null terminate like fgets() */
	return(n);
}
/* end readline */

ssize_t
Readline2(int fd, void *ptr, size_t maxlen)
{
	ssize_t		n;

	if ( (n = readline(fd, ptr, maxlen)) < 0)
		err_sys("readline error");
	return(n);
}


 执行部分截图 

 

服务端
 


 
 


 
 

客户端
 


 
 


 
 


 
 


 

                

        

        

    

  


    

      

        

            

              
                
                  游唐碧风
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
一文教你如何在Linux系统上搭建samba文件共享服务器

				
			

			

				

					dvlinker的技术专栏
				

				

					07-26
					
					66
					
				

			

		

		

			
				
一文教你如何在Linux系统上搭建samba文件共享服务器

			
		

	



                

              
                



	

		

			

				
					
【网络编程】linux 简单的服务器端客户端程序

				
			

			

				

					qq_40026625的博客
				

				

					07-23
					
					407
					
				

			

		

		

			
				
用VScode 完成我的第一个服务器端与客户端的互通

ios 教科书般的网络体系（实际中不用）：1物理层 2数据链路层 3网络层 4传输层 5会话层 6表示层 7应用层

常用的四层网络体系：网络接口层 网络层 传输层 应用层

顺便复习了一下几个简单的命令：暂时加行号 set nu, 删除文件夹 rm 文件名，改名 mv 原名字 要修改的名字移动文件：mv文件名 移动目的地文件名yy 复制整行（nyy或者yny ，复制n行，n为数字）；p 粘贴 重命名文件：mv文件名 修改后的文件名...

			
		

	



                


  
              

                


	

		

			

				
					
Linux下实现的简单文件服务器与客户端

				
			

			

				

					09-05
				

			

		

		

			
				
可查看服务器中可供下载的文件名字，支持从服务器下载文件到客户端，客户端上传文件到服务器。实现了一个简单的文件服务器上传下载功能

			
		

	





	

		

			

				
					
Linux搭建简单的http文件服务器11

				
			

			

				

					那些年的代码
				

				

					10-17
					
					744
					
				

			

		

		

			
				
http://192.168.31.69:8090/file/
http://47.92.90.25:21888/file/
在Ubuntu中通过apt-get install apache2 安装apache2
CentOS7中通过yum install httpd 安装httpd
apache2的配置文件是/etc/apache2/apache2.conf
httpd的配置文件是/etc/ht...

			
		

	



		

			
		



	

		

			

				
					
Linux中简单服务器（+-*/%）的与客户端的实现

				
			

			

				

					zzb2019的博客
				

				

					05-09
					
					212
					
				

			

		

		

			
				
头文件 utili.h
#pragma once 
#include
#include
#include
#include
#include
#include
#include
#include

#define BUFFER_SIZE 256
#define TCP 0
#define UDP 1
#define LISTW_QUEUE_SIZE 5

typedef enum {QUIT,A

			
		

	





	

		

			

				
					
从Linux服务器端下载文件Win客户端

				
			

			

				

					 Learn From The Masters
				

				

					05-21
					
					714
					
				

			

		

		

			
				
Linux服务端程序

//server_file.c
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;unistd.h&gt;
#include &lt;arpa/inet.h&gt;
#include &lt;sys/socket.h&gt;

#define B...

			
		

	





	

		

			

				
					
实例101  Linux下编程实现服务器与客户端的连接.rar_linux  编程_linux 服务器_linux下编程_服务器

				
			

			

				

					09-14
				

			

		

		

			
				
本实例"实例101 Linux下编程实现服务器与客户端的连接"主要涵盖了网络编程的基础知识，以及如何在Linux系统中应用这些知识来创建服务端和客户端程序。下面我们将深入探讨相关知识点。  首先，我们要了解的是TCP/IP...

			
		

	





	

		

			

				
					
基于linux系统的文件下载服务器-客户端-服务器端.zip

				
			

			

				

					07-31
				

			

		

		

			
				
这样的系统设计允许用户通过客户端程序登录并选择要下载的文件，而服务器端则负责处理请求，将所需的文件传输给客户端。以下是关于这个系统涉及的一些核心知识点：  1. **Linux操作系统**：Linux是一种开源、自由的...

			
		

	





	

		

			

				
					
实现一个简单的文件服务器

				
			

			

				

					weixin_59867016的博客
				

				

					07-13
					
					351
					
				

			

		

		

			
				
用java实现一个简单的文件服务器

			
		

	





	

		

			

				
					
linux echo服务客户端与服务器端程序

				
			

			

				

					11-26
				

			

		

		

			
				
linux echo服务客户端与服务器端程序

			
		

	





	

		

			

				
					
Linux Socket编程基于TCP的客户服务器程序和配置脚本

				
			

			

				

					07-26
				

			

		

		

			
				
资源包含客户端程序tcpclient.c,服务器端程序tcpserver.c，Makefile文件以及一个自动化配置安装脚本 setup.sh，具体使用方法如下：
1 即make为运行make命令编译 client 和server， 2. 即包括1中内容和运行服务器端，在后台运行， 3. 删除编译产生的 .o文件，4. 终止服务器端后台运行，并删除所有文件
        ------------------------------------
	Usage: sh setup <args>
	 args are Numbers as follows:
	 1. make, generate executions
	 2. run, make & run
	 3. make clean, rm *.o
	 4. make cleanall, rm files in 1&2
	----------------------
	 Exp: sh setup.sh 2 
	----------------------
	------------------------------------
在root权限下运行肯定没问题，在user权限下运行在笔者电脑上是没问题的

			
		

	





	

		

			

				
					
网络编程-一个简单的客户端与服务器程序(0)，（看这篇就够了）

				
			

			

				

					chen1415886044的博客
				

				

					02-23
					
					6644
					
				

			

		

		

			
				
写客户端与服务器程序之前，相信都对TCP的三次握手，四次挥手有一定的了解。如果还不了解的朋友可以看这两篇网络编程-从TCP三次握手说起和网络编程-TCP的四次挥手
服务器和客户端程序的流程
基于TCP/IP协议的服务器和客户端程序的一般流程，如下图所示：

1、服务器初始化一一LISTEN
(1)调用socket函数创建文件描述符。
(2)调用bind函数将当前的文件描述符和ip/port绑定在一...

			
		

	





	

		

			

				
					
一个简单的服务器和客户机程序

				
			

			

				

					qq_39061832的博客
				

				

					07-20
					
					1475
					
				

			

		

		

			
				
这个例子将以最简单的方式运用套接字对服务器和客户机进行操作。服务器的全部工作就是等候建立一个连接，然后用那个连接产生的Socket创建一个InputStream以及一个OutputStream。在这之后，它从InputStream读入的所有东西都会反馈给OutputStream，直到接收到行中止（END）为止，最后关闭连接。
    客户机连接与服务器的连接，然后创建一个OutputStream

			
		

	





	

		

			

				
					
一个简单的基于TCP通信的服务器端与客户端程序

				
			

			

				

					dangfulin的博客
				

				

					08-08
					
					2503
					
				

			

		

		

			
				
666



			
		

	





	

		

			

				
					
【高并发网络通信架构】1.Linux下实现单客户连接的tcp服务端

					
最新发布

				
			

			

				

					weixin_43729127的博客
				

				

					07-07
					
					2301
					
				

			

		

		

			
				
异步I/O（Asynchronous I/O）：通过使用异步I/O操作，可以在所有I/O操作之后返回，而不会阻塞当前线程。这将创建一个新的套接字，用于和客户端进行通信，而原始的监听套接字继续监听新的连接请求。这将创建一个新的套接字，用于和客户端进行通信，而原始的监听套接字继续监听新的连接请求。进行数据通信（Communicate）：使用已连接的套接字进行数据的读取和写入。监听连接请求（Listen）：将套接字置于监听状态，等待客户端的连接请求，使用。关闭套接字（Close）：当通信结束后，使用。

			
		

	





	

		

			

				
					
Linux编程基础 7.2：服务器和客户端编程案例

				
			

			

				

					爱学习爱运动的专栏
				

				

					05-13
					
					948
					
				

			

		

		

			
				
1 网络字节序
大端模式：若将数据的高字节保存在内存的低地址，将数据的低字节保存在内存的高地址；
小端模式：若将数据的高字节保存在内存的高地址，将数据的低字节保存在内存的低地址。

网络数据流：大端模式
计算机：大端/小端模式

Linux系统中提供了一些用于字节序转换的函数，这些函数存在于函数库arpa/inet.h中，它们的定义如下：
uint32_t htonl(uint32_t hostlong);//主机字节序转换为网络字节序（长整型）
uint16_t htons(uint16_t hostsh

			
		

	





	

		

			

				
					
linux 客户端程序,linux 管道 服务器客户端程序

				
			

			

				

					weixin_39625864的博客
				

				

					05-10
					
					81
					
				

			

		

		

			
				
服务器开启一个管道，并对这个管道进行读取操作。多个客户端对这个管道进行写入操作。服务器对于读管道进行阻塞以等待所有的客户端向这个管道写入数据。对于每个客户端只要它写入的数据小于PIPE_BUF.系统可以保证每一个客户端写入的数据都是各自的，而不会混乱的交错在一起。对于服务器发给客户端的应答，需要针对每一个客户端建立一个FIFO管道来反馈消息，之后客户端读操作监听返回的消息。服务端的代码#inclu...

			
		

	





	

		

			

				
					
Linux设备驱动程序详解：Java客户端服务器文件上传与接收

				
			

			

				

					
				

			

		

		

			
				
"设备驱动程序流程图-java客户端服务端上传接收文件实现详解" ...通过上述内容，我们可以全面地学习和掌握嵌入式Linux应用程序开发的基础知识，从而能够设计和实现设备驱动，处理客户端和服务器端的文件传输。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值