Linux下socket传输文件示例

为了方便获取在嵌入式设备中生成的文件，可以在嵌入式端建立一个文件服务器

/*server.c*/
#include<netinet/in.h>  
#include<sys/types.h>  
#include<sys/socket.h>  
#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
  
#define HELLO_WORLD_SERVER_PORT    8187  
#define LENGTH_OF_LISTEN_QUEUE     20  
#define BUFFER_SIZE                (1024) 
#define FILE_NAME_MAX_SIZE         512  
  
int main(int argc, char **argv)  
{  
    struct sockaddr_in   server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);  
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
  
    int server_socket = socket(PF_INET, SOCK_STREAM, 0);  
    if (server_socket < 0)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  
  
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))  
    {  
        printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);  
        exit(1);  
    }  
    
    if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))  
    {  
        printf("Server Listen Failed!\n");  
        exit(1);  
    }  
    while(1)  
    {   
        struct sockaddr_in client_addr;  
        socklen_t length = sizeof(client_addr);  
  
        int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);  
        if (new_server_socket < 0)  
        {  
            printf("Server Accept Failed!\n");  
            break;  
        }  
        char buffer[BUFFER_SIZE];  
        bzero(buffer, sizeof(buffer));  
        length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);  
        if (length < 0)  
        {  
            printf("Server Recieve Data Failed!\n");  
            break;  
        }  
  
        char file_name[FILE_NAME_MAX_SIZE + 1];  
        bzero(file_name, sizeof(file_name));  
        strncpy(file_name, buffer,  
                strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));  
  
        FILE *fp = fopen(file_name, "r");  
        if (fp == NULL)  
        {  
            printf("File:\t%s Not Found!\n", file_name);  
        }  
        else  
        {  
            bzero(buffer, BUFFER_SIZE);  
            int file_block_length = 0;  
            while( (file_block_length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)  
            {  
                printf("file_block_length = %d\n", file_block_length);  
                if (send(new_server_socket, buffer, file_block_length, 0) < 0)  
                {  
                    printf("Send File:\t%s Failed!\n", file_name);  
                    break;  
                }   
                bzero(buffer, sizeof(buffer));  
            }  
            fclose(fp);  
            printf("File:\t%s Transfer Finished!\n", file_name);  
        }   
        close(new_server_socket);  
    }   
    close(server_socket);   
    return 0;  
}  

/*client*/
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<stdlib.h> 
#include<string.h>                              
#include <arpa/inet.h>
#include <unistd.h>
  
#define HELLO_WORLD_SERVER_PORT       8187  
#define BUFFER_SIZE                   (1024)
#define FILE_NAME_MAX_SIZE            512  
  
int main(int argc, char **argv)  
{  
    if (argc != 2)  
    {  
        printf("Usage: ./%s ServerIPAddress\n", argv[0]);  
        exit(1);  
    }  
  
    struct sockaddr_in client_addr;  
    bzero(&client_addr, sizeof(client_addr));  
    client_addr.sin_family = AF_INET; 
    client_addr.sin_addr.s_addr = htons(INADDR_ANY); 
    client_addr.sin_port = htons(0); 
  
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);  
    if (client_socket < 0)  
    {  
        printf("Create Socket Failed!\n");  
        exit(1);  
    }  
  
    if (bind(client_socket, (struct sockaddr*)&client_addr, sizeof(client_addr)))  
    {  
        printf("Client Bind Port Failed!\n");  
        exit(1);  
    }  
  
    struct sockaddr_in  server_addr;  
    bzero(&server_addr, sizeof(server_addr));  
    server_addr.sin_family = AF_INET;  
    if (inet_aton(argv[1], &server_addr.sin_addr) == 0)  
    {  
        printf("Server IP Address Error!\n");  
        exit(1);  
    }  
  
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);  
    socklen_t server_addr_length = sizeof(server_addr);  
  
    if (connect(client_socket, (struct sockaddr*)&server_addr, server_addr_length) < 0)  
    {  
        printf("Can Not Connect To %s!\n", argv[1]);  
        exit(1);  
    }  
  
    char file_name[FILE_NAME_MAX_SIZE + 1];  
    bzero(file_name, sizeof(file_name));  
    printf("Please Input File Name On Server: ");  
    scanf("%s", file_name);  
  
    char buffer[BUFFER_SIZE];  
    bzero(buffer, sizeof(buffer));  
    strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));   
    send(client_socket, buffer, BUFFER_SIZE, 0);  
  
    FILE *fp = fopen(file_name, "w");  
    if (fp == NULL)  
    {  
        printf("File:\t%s Can Not Open To Write!\n", file_name);  
        exit(1);  
    }  
   
    bzero(buffer, sizeof(buffer));  
    int length = 0;  
    while(length = recv(client_socket, buffer, BUFFER_SIZE, 0))  
    {  
        if (length < 0)  
        {  
            printf("Recieve Data From Server %s Failed!\n", argv[1]);  
            break;  
        }  
  
        int write_length = fwrite(buffer, sizeof(char), length, fp);  
        if (write_length < length)  
        {  
            printf("File:\t%s Write Failed!\n", file_name);  
            break;  
        }  
        bzero(buffer, BUFFER_SIZE);  
    }  
  
    printf("Recieve File:\t %s From Server[%s] Finished!\n", file_name, argv[1]);  
   
    fclose(fp);  
    close(client_socket);  
    return 0;  
  
} 

win32平台的client

/*client.c*/
#include <iostream>
#include <cstdio>
#include <windows.h>
#include <cstring>
#include <Winsock2.h>
#include <time.h>

using namespace std;

#define HELLO_WORLD_SERVER_PORT       8187  
#define BUFFER_SIZE                   (1024)
#define FILE_NAME_MAX_SIZE            512  

int main(int argc, char **argv)
{
	int err;
	int i;
	char ip[16];
	char str[8];
	//memcpy(str, "[ipaddr]", 8);
	char temp[24];
	int n;
	
	/*printf("Please input the IPC address: ");
	scanf("%s", ip);
	if (strlen(ip) > 16)
	{
		printf("IPC address format false.\n");
		printf("Please enter any key to exit.\n");
		system("pause");
		exit(1);
	}*/
	
	FILE *pconf = fopen("config.txt", "r+");
	n = fread(temp, sizeof(temp), 1, pconf);
	printf("n: %d\n", n);
	memcpy(str, temp, 8);
	memcpy(ip, temp+8, 16);
	printf("%s\n", temp);
	printf("%s\n", str);
	printf("%s\n", ip);
	

// 加载socket动态链接库(dll)
	WORD wVersionRequested;
	WSADATA wsaData;	// 这结构是用于接收Wjndows Socket的结构信息的 
	wVersionRequested = MAKEWORD(1, 1);	// 请求1.1版本的WinSock库 
	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) {
		return -1;			// 返回值为零的时候是表示成功申请WSAStartup
	}
	 
	if ( LOBYTE( wsaData.wVersion ) != 1 ||	HIBYTE( wsaData.wVersion ) != 1 ) {
		// 检查这个低字节是不是1，高字节是不是1以确定是否我们所请求的1.1版本
		// 否则的话，调用WSACleanup()清除信息，结束函数
		WSACleanup( );
		return -1; 
	}
	
// 创建socket操作，建立流式套接字，返回套接字号sockClient
	// SOCKET socket(int af, int type, int protocol);
	// 第一个参数，指定地址簇(TCP/IP只能是AF_INET，也可写成PF_INET)
	// 第二个，选择套接字的类型(流式套接字)，第三个，特定地址家族相关协议（0为自动）
	SOCKET sockClient = socket(AF_INET, SOCK_STREAM, 0);

// 将套接字sockClient与远程主机相连
	// int connect( SOCKET s,  const struct sockaddr* name,  int namelen);
	// 第一个参数：需要进行连接操作的套接字
	// 第二个参数：设定所需要连接的地址信息
	// 第三个参数：地址的长度
	
	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr = inet_addr(ip);
	addrSrv.sin_family = AF_INET;
	addrSrv.sin_port = htons(HELLO_WORLD_SERVER_PORT);
	connect(sockClient, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));
	
	char file_name[FILE_NAME_MAX_SIZE + 1];  
    memset(file_name, 0, sizeof(file_name));  
    //printf("Please Input File Name On Server: ");  
    //scanf("%s", file_name);
	strcpy(file_name, "picture.jpg");
  
    char buffer[BUFFER_SIZE];  
    memset(buffer, 0, sizeof(buffer));  
    strncpy(buffer, file_name, strlen(file_name) > BUFFER_SIZE ? BUFFER_SIZE : strlen(file_name));  
    // 向服务器发送buffer中的数据，此时buffer中存放的是客户端需要接收的文件的名字  
    send(sockClient, buffer, BUFFER_SIZE, 0); 
	
	FILE *fp = fopen(file_name, "wb");  
    if (fp == NULL)  
    {  
        printf("File:\t%s Can Not Open To Write!\n", file_name);  
        exit(1);  
    }  
  
    // 从服务器端接收数据到buffer中  
    memset(buffer, 0,sizeof(buffer));  
    int length = 0;  
    while(length = recv(sockClient, buffer, BUFFER_SIZE, 0))  
    {  
        if (length < 0)  
        {  
            printf("Recieve Data From Server %s Failed!\n", argv[1]);  
            break;  
        }  
		//printf("length: %d\n", length);
        int write_length = fwrite(buffer, sizeof(char), length, fp);  
        if (write_length < length)  
        {  
            printf("File: %s Write Failed!\n", file_name);  
            break;  
        }  
        memset(buffer, 0, BUFFER_SIZE);  
    }  
  
    printf("Recieve File: %s From Server[%s] Finished!\n", file_name, ip);
	
	fclose(pconf);
	fclose(fp); 
	closesocket(sockClient);
	WSACleanup();
	return 0;
}