您的位置：360文档中心› socket图片文件传输示例

socket图片文件传输示例

合集下载

socket传输文件的原理

socket传输文件的原理

socket传输文件的原理
文件传输是计算机网络中的一项基本功能，它允许在网络上的不同计算机之间共享和传输文件。

Socket是实现文件传输的一种常用方式，其原理如下：
1. 建立连接：在进行文件传输之前，需要在发送方和接收方之间建立连接。

这通常通过TCP/IP 协议实现，使用Socket进行连接的建立。

一旦连接建立成功，发送方和接收方就可以通过该连接进行数据传输。

2. 文件分割：由于文件通常较大，不适合一次性传输，因此需要将文件分割成较小的数据块。

这些数据块可以按照一定的顺序进行编号，以便于接收方重新组合成完整的文件。

3. 发送数据：发送方通过Socket将分割好的数据块逐个发送给接收方。

在发送数据时，需要按照一定的协议进行数据的封装，例如添加文件名、数据块大小等信息。

4. 接收数据：接收方通过Socket接收到数据后，需要按照发送方的协议对数据进行解析和处理。

接收方会将收到的数据块进行缓存，以便后续重新组合成完整的文件。

5. 确认机制：为了确保文件传输的完整性和正确性，发送方和接收方之间需要建立一种确认机制。

例如，发送方可以发送一个数据包的编号给接收方，接收方在收到数据包后回复一个确认信号给发送方，表示该数据包已经成功接收。

如果发送方在一定时间内没有收到确认信号，则会重新发送数据包，以确保数据的可靠传输。

6. 关闭连接：当文件传输完成后，发送方和接收方之间的连接会被关闭。

这可以通过Socket 的关闭函数实现，释放网络资源。

通过以上步骤，使用Socket可以实现文件的传输。

在实际应用中，不同的文件传输协议可能会有一些差异，但基本原理是相同的。

socket实现进程通信传输任意大小文件

socket实现进程通信传输任意大小文件

lseek(fileopen,datarecv.oplencount,SEEK_SET);
if( ( writelen += write(fileopen,datarecv.filebuf,datarecv.shouldoplen) ) <0 ){ printf("write error!\n"),exit(-1);
说明：在 clinet 端与 server 通信时，发送太大的文件，无法一次性发送，只能多次发送，这样就涉及到 几个问题？ 发送多少次？ 一次发送多大？ Server 保存时候怎么保存？
我的解决办法是： 根据实际文件大小和自定义的 buf 来比较，通过循环判断，来决定一次读出多少字节， 进而发送多少字节，通过 lseek 来实现 。
printf("\nserver closed right now!!\n"); close(sockid); close(fileopen); exit(0);
}
int main(int argc,char* argv[]) {
signal(SIGINT,(__sighandler_t)f_quit); sockid = socket(PF_UNIX,SOCK_DGRAM,0); if(sockid == -1)
printf("%m\n"),exit(-1); printf("read %s successfully ! readlen=%d\n",datasent->filename,readlen);
//printf("%s\n",datasent->filebuf); }
int sentdata(struct data datasent) {

【Java基于Socket文件传输示例】网络编程

【Java基于Socket文件传输示例】网络编程

Java基于Socket文件传输示例最近需要进行网络传输大文件，于是对基于socket的文件传输作了一个初步的了解。

在一位网友提供的程序基础上，俺进行了一些加工，采用了缓冲输入/输出流来包装输出流，再采用数据输入/输出输出流进行包装，加快传输的速度。

废话少说，先来看服务器端的程序。

1.服务器端package sterning;import java.io.BufferedInputStream;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.File;import java.io.FileInputStream;import .ServerSocket;import .Socket;public class ServerTest {int port = 8821;void start() {Socket s = null;try {ServerSocket ss = new ServerSocket(port);while (true) {// 选择进行传输的文件String filePath = "D:\\lib.rar";File fi = new File(filePath);System.out.println("文件长度:" + (int) fi.length());// public Socket accept() throws// IOException侦听并接受到此套接字的连接。

此方法在进行连接之前一直阻塞。

s = ss.accept();System.out.println("建立socket链接");DataInputStream dis = new DataInputStream(new BufferedIn putStream(s.getInputStream()));dis.readByte();DataInputStream fis = new DataInputStream(new BufferedIn putStream(new FileInputStream(filePath)));DataOutputStream ps = new DataOutputStream(s.getOutput Stream());//将文件名及长度传给客户端。

使用socket进行服务端与客户端传文件的方法

使用socket进行服务端与客户端传文件的方法

使⽤socket进⾏服务端与客户端传⽂件的⽅法逻辑：1.客户端将需要查找的⽂件名以流的形式传给服务端2.服务端接受客户端的连接，把流转化为字符串，进⾏⼀个⽬录的遍历，查找是否存在需要的⽂件，若未找到，则输出未找到，若找到，则将⽂件转化为流，传给客户端3.客户端准备接受，将服务端传过来的流转化为⽂件，存储下载。

4，⾄此，完成⼀个简单的客户端与服务端传输⽂件的⼩栗⼦~Client.Javapackage com.ysk;import java.io.BufferedReader;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.OutputStreamWriter;import java.io.PrintWriter;import .ServerSocket;import .Socket;import .UnknownHostException;public class Client {public static void main(String[] args) {try {Socket socket = new Socket("127.0.0.1", 5555);OutputStream os = socket.getOutputStream();// 字节输出流PrintWriter pw = new PrintWriter(os);pw.write("aa.txt");//输⼊需要搜索的⽂件名pw.flush();socket.shutdownOutput();BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));String a = "";String temp = "";while ((temp = in.readLine()) != null) {a += temp;}PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream("src\\asb.txt")));out.write(a);out.flush();out.close();} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {}}}Server.javapackage com.ysk;import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.io.PrintWriter;import .ServerSocket;import .Socket;public class Server {static ServerSocket serverSocket;public static void main(String[] args) {try {serverSocket = new ServerSocket(5555);System.out.println("***服务器即将启动，等待客户端的连接***");Socket socket = serverSocket.accept();BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));String file = br.readLine();findFile("src", file);if (result) {System.out.println("已找到" + file);File f = new File(file);// File copyfile = new File("src\\file", "bb.txt");BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(filepath + file)));System.out.println(filepath + file);String a = "";String temp = "";while ((temp = in.readLine()) != null) {a += temp;}PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));out.write(a);out.flush();socket.shutdownOutput();} else {System.out.println("未找到⽂件");}} catch (IOException e) {e.printStackTrace();}}需⾃备aa.txt，这种资源⽂件，以便测试。

Java基于Socket文件传输示例2007(An-Beer 工作室)

Java基于Socket文件传输示例2007(An-Beer 工作室)

Java基于Socket文件传输示例2007-10-15 来自：lizhe1985 [收藏到我的网摘]来源：诗特林-sterning - BlogJava最近需要进行网络传输大文件，于是对基于socket的文件传输作了一个初步的了解。

在一位网友提供的程序基础上，俺进行了一些加工，采用了缓冲输入/输出流来包装输出流，再采用数据输入/输出输出流进行包装，加快传输的速度。

废话少说，先来看服务器端的程序。

1.服务器端package sterning;import java.io.BufferedInputStream;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.File;import java.io.FileInputStream;import .ServerSocket;import .Socket;public class ServerTest {int port = 8821;void start() {Socket s = null;try {ServerSocket ss = new ServerSocket(port); while (true) {// 选择进行传输的文件String filePath = "D:\\lib.rar";File fi = new File(filePath);System.out.println("文件长度:" + (int)fi.length());// public Socket accept() throws// IOException侦听并接受到此套接字的连接。

此方法在进行连接之前一直阻塞。

s = ss.accept();System.out.println("建立socket链接"); DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream())); dis.readByte();DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath))); DataOutputStream ps = new DataOutputStream(s.getOutputStream());//将文件名及长度传给客户端。

Socket编程实现文件上传

Socket编程实现文件上传
2.Socket 文件上传的编程实现
(1)服务器端的实现代码 package server;
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import .BindException; import .ServerSocket; import .Socket; import java.text.SimpleDateFormat; import java.util.Date; /**
public static void main(String arg[]) throws Exception { ClientUpload clientTest = new ClientUpload(); clientTest.setUpConnection(); clientTest.getMessage(); clientTest.sendMessage();
String fileName = null; String thisDateStr = null; try {
DataOutputStream sendMsg = new DataOutputStream(socketConnection .getOutputStream());
String randomId = getResourceId(); Date thisDate = new Date(); SimpleDateFormat dayFormat = new SimpleDateFormat("MMDD"); thisDateStr = dayFormat.format(thisDate); fileName = thisDateStr + randomId; sendMsg.writeUTF(fileName); sendMsg.flush(); } catch (Exception e) { System.out.println("发送消息错误" + "\n"); return; } DataInputStream inputStream = null; try { inputStream = new DataInputStream(new BufferedInputStream(

sockaddr_文件传输案例

什么是SocketSocket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。

要学Internet上的TCP/IP网络编程，必须理解Socket 接口。

Socket接口设计者最先是将接口放在Unix操作系统里面的。

如果了解Unix系统的输入和输出的话，就很容易了解Socket了。

网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。

Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

常用的Socket类型有两种：流式Socket （SOCK_STREAM）和数据报式Socket （SOCK_DGRAM）。

流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

Socket建立为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。

socket函数原型为：int socket(int domain, int type, int protocol);domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type 参数指定socket的类型：SOCK_STREAM 或SOCK_DGRAM，Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值"0"。

Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。

Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。

调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。

UnitySockect实现画面实时传输案例原理解析

UnitySockect实现画⾯实时传输案例原理解析⽬录前⾔⼀、Socket通信原理⼆、画⾯传输设计1.逻辑设计图2.Unity服务端3.Unity客户端4.最终效果前⾔提⽰：这⾥可以添加本⽂要记录的⼤概内容：例如：随着⼈⼯智能的不断发展，机器学习这门技术也越来越重要，很多⼈都开启了学习机器学习，本⽂就介绍了机器学习的基础内容。

提⽰：以下是本篇⽂章正⽂内容，下⾯案例可供参考⼀、Socket通信原理Socket是⽐较常⽤的⼀种通信⽅式。

有关介绍可以点击查看Socket通信原理⼆、画⾯传输设计1.逻辑设计图2.Unity服务端⾸先创建⼀个Unity⼯程，然后新建Server场景，⽤于接受数据，展⽰画⾯。

然后再场景中创建⼀个RawImage并设置为全屏。

如图：然后创建⼀个脚本，命名为UnityServer，再创建⼀个UnityServer.cs在Start函数中创建Socket服务器，并开启⼀个线程⽤于接受数据。

这⾥要注意⼀点，不能在接受数据线程中处理数据，需要在主线程中进⾏处理。

因为Unity主线程⾥⾯的资源不允许其他线程进⾏访问。

在Update函数中处理数据，并展⽰图⽚。

UnityServer .cs代码如下：using System;using System.Collections.Generic;using System.IO;using ;using .Sockets;using System.Threading;using UnityEngine;using UnityEngine.UI;public class UnityServer : MonoBehaviour {Socket socket = null;Thread thread = null;byte[] buffer = null;bool receState = true;int readTimes = 0;public RawImage rawImage;private Queue<byte[]> datas;void Start () {buffer = new byte[1024 * 1024 * 10];// 创建服务器, 以Tcp的⽅式socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);socket.Connect(IPAddress.Parse("192.168.1.87"), 10002);// 开启⼀个线程, ⽤于接受数据thread = new Thread(new ThreadStart(Receive));thread.Start();datas = new Queue<byte[]>();}private void Receive(){while (thread.ThreadState == ThreadState.Running && socket.Connected){// 接受数据Buffer count是数据的长度int count = socket.Receive(buffer);if (receState && count > 0){receState = false;BytesToImage(count, buffer);}}}MemoryStream ms = null;public void BytesToImage(int count, byte[] bytes){try{ms = new MemoryStream(bytes, 0, count);datas.Enqueue(ms.ToArray()); // 将数据存储在⼀个队列中，在主线程中解析数据。

c++socket文件传输实现思路

c++socket文件传输实现思路在C++中使用套接字（sockets）进行文件传输通常涉及到客户端和服务器端的通信。

下面是一个简单的文件传输实现思路，包含一个简单的服务器和客户端。

服务器端实现思路：1. 创建套接字：使用`socket()`函数创建一个套接字。

2. 绑定套接字：使用`bind()`函数将套接字绑定到一个特定的端口。

3. 监听连接请求：使用`listen()`函数监听来自客户端的连接请求。

4. 接受连接：使用`accept()`函数接受客户端的连接请求，返回一个新的套接字用于与该客户端通信。

5. 接收文件信息：接受客户端发送的文件信息，包括文件名和文件大小。

6. 接收文件数据：根据文件大小，使用`recv()`函数多次接收文件数据。

7. 保存文件：将接收到的文件数据保存到服务器上的文件。

8. 关闭套接字：在文件传输完成后，关闭套接字。

客户端端实现思路：1. 创建套接字：使用`socket()`函数创建一个套接字。

2. 连接服务器：使用`connect()`函数连接到服务器的地址和端口。

3. 打开文件：打开要传输的文件，获取文件名和文件大小。

4. 发送文件信息：发送文件信息给服务器，包括文件名和文件大小。

5. 发送文件数据：按照设定的数据块大小，多次使用`send()`函数发送文件数据。

6. 关闭套接字：在文件传输完成后，关闭套接字。

下面是一个简单的例子，涉及到服务器端和客户端的基本实现：服务器端代码：```cpp#include <iostream>#include <fstream>#include <sstream>#include <cstring>#include <sys/socket.h>#include <netinet/in.h>int main() {// 创建套接字int serverSocket = socket(AF_INET, SOCK_STREAM, 0);// 绑定套接字到端口sockaddr_in serverAddress;serverAddress.sin_family = AF_INET;serverAddress.sin_port = htons(12345);serverAddress.sin_addr.s_addr = INADDR_ANY;bind(serverSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress));// 监听连接请求listen(serverSocket, 5);// 接受连接int clientSocket = accept(serverSocket, NULL, NULL);// 接收文件信息char buffer[1024];recv(clientSocket, buffer, sizeof(buffer), 0);std::istringstream iss(buffer);std::string fileName;std::size_t fileSize;iss >> fileName >> fileSize;// 接收文件数据并保存到服务器上std::ofstream outputFile(fileName, std::ios::binary);while (fileSize > 0) {std::size_t bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);outputFile.write(buffer, bytesRead);fileSize -= bytesRead;}// 关闭套接字close(clientSocket);close(serverSocket);}```客户端代码：```cpp#include <iostream>#include <fstream>#include <sstream>#include <cstring>#include <sys/socket.h>#include <netinet/in.h>int main() {// 创建套接字int clientSocket = socket(AF_INET, SOCK_STREAM, 0);// 连接到服务器sockaddr_in serverAddress;serverAddress.sin_family = AF_INET;serverAddress.sin_port = htons(12345);serverAddress.sin_addr.s_addr = inet_addr("server_ip_address");connect(clientSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress));// 打开文件std::ifstream inputFile("file_to_send.txt", std::ios::binary);std::ostringstream oss;oss << "file_to_send.txt " << inputFile.tellg();std::string fileInfo = oss.str();// 发送文件信息send(clientSocket, fileInfo.c_str(), fileInfo.size(), 0);// 发送文件数据char buffer[1024];while (!inputFile.eof()) {inputFile.read(buffer, sizeof(buffer));send(clientSocket, buffer, inputFile.gcount(), 0);}// 关闭套接字close(clientSocket);}```请注意，上述代码只是一个基本示例，可能需要根据实际需求进行改进和优化。

socket编程实例(文件传输)

´ËʵÀýÊÇ¿Í»§¶ËÏò·þÎñÆ÷¶Ë´«ËÍÎļþ·þÎñÆ÷¶Ë´úÂëʵÏÖ£º#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/types.h>#include <sys/socket.h>#include <sys/stat.h>#include <unistd.h>#include <arpa/inet.h>#include <errno.h>#include <fcntl.h>#define FU_SERVER_PORT 8080 /*set port*/#define FU_BUFFERSIZE 1024 /*set buffer size*/#define FU_LISTENQ 10 /*set listen max conncent*/int main(int argc,char *argv[]){int fu_listenfd,fu_connfd,fu_filefd; /*descriptor*/int fu_read,fu_write;int struct_size;struct sockaddr_in fu_servaddr,fu_cliaddr;char *fu_filename;char *p;char buffer[FU_BUFFERSIZE];fu_listenfd=socket(AF_INET,SOCK_STREAM,0); /*create socket*/if(fu_listenfd==-1){perror("fu_socket");exit(1);}memset(&fu_servaddr,0,sizeof(fu_servaddr)); /*servaddr set 0*/fu_servaddr.sin_family=AF_INET; /*init serveraddr*/fu_servaddr.sin_addr.s_addr=INADDR_ANY;fu_servaddr.sin_port=htons(FU_SERVER_PORT);/*bind fu_listenfd*/if(-1==(bind(fu_listenfd,(struct sockaddr *)&fu_servaddr, sizeof(fu_servaddr)))){exit(1);}/*listen fu_listenfd*/if(-1==(listen(fu_listenfd,FU_LISTENQ))){perror("fu_listen");exit(1);}/*file upload server start*/while(1){printf("file upload server starting......\n");memset(&fu_cliaddr,0,sizeof(fu_cliaddr));struct_size=sizeof(fu_cliaddr);fu_connfd=accept(fu_listenfd,(struct sockaddr *)&fu_cliaddr,&struct_size); if(-1==fu_connfd){perror("fu_accpet");continue;}fu_filename="/root/backup.txt";printf("will upload file name is:%s\n",fu_filename);fu_filefd=open(fu_filename,O_RDWR|O_CREAT|O_TRUNC,S_IRWXU);if (fu_filefd<0) {perror("open localhost file");continue;}while(fu_read=read(fu_connfd,buffer,FU_BUFFERSIZE)) {if (fu_read< 0) {perror("read client file");break;}if (-1==write(fu_filefd,buffer,fu_read)) {perror("writing to filefd error");break;}}if(-1==fu_read||-1==fu_write) continue;close(fu_filefd);printf("file upload success!\n");}close(fu_listenfd);return 0;}¿Í»§¶Ë´úÂëʵÏÖ£º#include <stdio.h>#include <stdlib.h>#include <string.h>#include <sys/types.h>ar#include <sys/socket.h>#include <sys/stat.h>#include <unistd.h>#include <arpa/inet.h>#include <errno.h>#include <fcntl.h>#define FU_SERVER_PORT 8080 /*set port*/#define FU_BUFFERSIZE 1024 /*set buffer size*/int main(int argc,char *argv[]){int fu_sockfd,fu_filefd; /*descriptor*/int fu_read,fu_write;int struct_size;struct sockaddr_in fu_sockaddr;char *fu_filename;char *p;char buffer[FU_BUFFERSIZE];if (argc!=2) {perror("fu_Usage: <./client> <server IP>\n");exit(1);}fu_sockfd=socket(AF_INET,SOCK_STREAM,0); /*create socket*/if(fu_sockfd==-1){perror("fu_socket");exit(1);}memset(&fu_sockaddr,0,sizeof(fu_sockaddr)); /*servaddr set 0*/fu_sockaddr.sin_family=AF_INET; /*init serveraddr*/inet_aton(argv[1],&fu_sockaddr.sin_addr);fu_sockaddr.sin_port=htons(FU_SERVER_PORT);if(-1==(connect(fu_sockfd,(struct sockaddr *)&fu_sockaddr,sizeof(fu_sockaddr)))){ perror("fu_connect");exit(1);}printf("start connecting..........\n");fu_filename="./will.txt";printf("will upload file name is:%s\n",fu_filename);fu_filefd=open(fu_filename,O_RDONLY);if(-1==fu_filefd){perror("open will upload file");exit(1);}while(fu_read=read(fu_filefd,buffer,FU_BUFFERSIZE)){if(-1==fu_read){perror("read will upload file");exit(1);}p=buffer;while(fu_write=write(fu_sockfd,p,fu_read)){if(-1==fu_write){perror("write client file");break;}else if(fu_read==fu_write) break;else if(fu_write>0){p+=fu_write;fu_read-=fu_write;}}if(-1==fu_write) exit(1);}close(fu_filefd);close(fu_sockfd);printf("file already is uploaded!\n");}。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

从前在网上找过很多ｓｏｃｋ编程的资料，都很高深。。。。 对于入门级的我来说，简单又不简陋的小例子更好一些，所以总结一下刚写的小例子， 用select模型实现的ｊｐｇ文件传输，并不完善，只作为今后的一个参考。 代码经过调试，应该能用吧。。。。。

服务器端：

#pragma comment (lib,"ws2_32.lib") #include #include #define BUFLEN sizeof(buf)

int main() { WSADATA wsaData; SOCKADDR_IN seraddr,cliaddr; SOCKET listensocket,newconnection,tempsocket; ULONG sockmode; int sockok,totalsock=0; struct fd_set fdwrite,fdread; char buf[10],buf0[10]; union { char a[4]; int b; }a,flag; a.b=flag.b=0; int cliaddrlen=sizeof(cliaddr); FILE *fp; long code; int n,he=0,m=0,k=0,b=0; char *p;

if ( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 ) { printf("error1");

return -1;} if((listensocket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==INVALID_SOCKET) { printf("error2"); return -1; } seraddr.sin_family=AF_INET; seraddr.sin_port=htons(8889); seraddr.sin_addr.s_addr=inet_addr("127.0.0.1"); if(SOCKET_ERROR==bind(listensocket,(SOCKADDR*)&seraddr,sizeof(seraddr))) { printf("error3"); return -1; }

if(SOCKET_ERROR==listen(listensocket,5)) { printf("error4"); return -1; } printf("wait ask"); sockmode=1;

if(SOCKET_ERROR==ioctlsocket(listensocket,FIONBIO,&sockmode)) { printf("error on ioctl"); return -1; } if((fp=fopen("output.jpg","rb"))==NULL) //指定的文件是否存在 { //指定文件不存在 printf("不能打开指定的文件!\n"); } fseek(fp,0,SEEK_END); //读写指针移动到文件结尾 k=a.b=ftell(fp); code=htonl(m); //返回当前读写指针的位置，即得到文件长度。 p=(char *)&k; while(1) { FD_ZERO(&fdread); FD_ZERO(&fdwrite); FD_SET(listensocket,&fdread); for(int i=0;i{ FD_SET(tempsocket,&fdread); FD_SET(tempsocket,&fdwrite); }

if(SOCKET_ERROR==(sockok=select(NULL,&fdread,&fdwrite,NULL,NULL))) { printf("error on select"); return -1; } if(FD_ISSET(listensocket,&fdread)) { sockok--;

if(INVALID_SOCKET==(newconnection=accept(listensocket,(SOCKADDR*)&cliaddr,&cliaddrlen))) { printf("error5"); return -1; } else { printf("come"); totalsock++; tempsocket=newconnection; }

if(SOCKET_ERROR==ioctlsocket(newconnection,FIONBIO,&sockmode)) { printf("error on ioctl"); return -1; } }

memset(buf,0,sizeof(buf)); //memset(buf0,0,sizeof(buf0)); if(FD_ISSET(newconnection,&fdread)) { memset(buf,0,sizeof(buf)); if(flag.b==2) {

if(recv(newconnection,flag.a,sizeof(flag),0)<0) { printf("error on recv long"); return -1; } //if(a.b==0) a.b=2; } //else

//if(recv(newconnection,buf,sizeof(buf),0)==SOCKET_ERROR) //{ // printf("error on recv ack"); // return -1; // } //if(strcmp(buf,"exit")==0) // { // printf("conplete copy"); // break; // } } if(FD_ISSET(newconnection,&fdwrite)) { //gets(buf0); sockok--;

if(a.b&&flag.b==0) { if((b=send(newconnection,a.a,sizeof(a),0))<0) { printf("error on send"); return -1;

//memset(a.a,0,sizeof(a)); } flag.b=2; } if(flag.b==1) {

// 打开文件，并把文件内容发送到客户方，然后关闭文件和套接字 rewind(fp); //文件读写指针移动到文件开头 while(!feof(fp)) //文件未结束 { memset(buf,0,BUFLEN); //清除缓存中的内容 n=fread(buf,1,BUFLEN,fp); //读取文件内容到缓存 if(m=send(newconnection,buf,n,0)) { if(m<0) { printf("error on send main"); m=GetLastError(); return -1; } if((he+=m)>=k) printf("copy complete"); }//send(clientSock,buf,n,0); //把文件内容发送给客户方

} fclose(fp); break; } //if(strcmp(buf0,"exit")==0) // break; } } WSACleanup( ); gets(buf); printf("exit to exit"); if(strcmp("exit",buf)) return 0;

} 客户端： #pragma comment (lib,"ws2_32.lib") #include #include #include

int main() { WSADATA wsaData; SOCKADDR_IN cliaddr; SOCKET scon; char buf0[50];

int n=0,m=0; int j=0,k=0,l=0,q=0; union{ char a[4]; int b; }a;//存储文件长度，用字符型指针做接收发送ａｐｉ的参数，然后用ｉｎｔ型运算 int sockok; struct fd_set fdwrite,fdread; int cliaddrlen=sizeof(cliaddr); ULONG sockmode=1; FILE *fp; if ( WSAStartup( MAKEWORD(2,0), &wsaData ) != 0 )//初始化套接字空间 { printf("error1");

return -1;}

相关文档
最新文档