linux socket c/s上传文件

这是上传文件的一个示例，可以参照自行修改成下载或者其它功能。

在上传时，需要先将文件名传到服务器端，这是采用一个结构体，包含文件名及文件名长度（可以用于校验），防止文件名乱码。

client

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 1492
#define SERV_PORT 5555
#define FILE_NAME_LEN 64

struct fileInfo{
    char fileName[FILE_NAME_LEN];
    int len;
};

int main(int argc, char *argv[])
{
    if(argc<){
        perror("Usage:./a.out ip filename");
        exit(-);
    }
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd;
    //char servip[]="123.206.59.137";
    sockfd = Socket(AF_INET, SOCK_STREAM, );
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, argv[], &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);
    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    struct fileInfo file_name;
    memset(&file_name,,sizeof(file_name));
    strncpy(file_name.fileName,argv[],strlen(argv[]));
    file_name.len=strlen(argv[]);
    Write(sockfd,&file_name,sizeof(file_name));
    FILE *fp=fopen(argv[],"r");
    if(fp==NULL){
        perror("open file failed");
        Close(sockfd);
        exit(-);
    }
    printf("open file %s successed\n",argv[]);
    int len=;
    while ((len=fread(buf,sizeof(char),MAXLINE,fp))>) {
        Write(sockfd, buf, len);
    }
    fclose(fp);
    Close(sockfd);
    return ;
}

server

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "wrap.h"
#define MAXLINE 1492
#define SERV_PORT 5555
#define FILE_NAME_LEN 64
struct fileInfo{
    char fileName[FILE_NAME_LEN];
    int len;
};

int main(int argc, char *argv[]){
    struct sockaddr_in serveraddr;
    int listenfd;
    char str[INET_ADDRSTRLEN];

    listenfd=Socket(AF_INET,SOCK_STREAM,);
    bzero(&serveraddr,sizeof(serveraddr));
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
    serveraddr.sin_port=htons(SERV_PORT);

    Bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
    Listen(listenfd,);

    while(){
        struct sockaddr_in clientaddr;
        socklen_t addrLen=sizeof(clientaddr);
        int confd=Accept(listenfd,(struct sockaddr *)&clientaddr,&addrLen);
        printf("receive file from %s at port %d\n",
            inet_ntop(AF_INET,&clientaddr.sin_addr,str,sizeof(str)),
            ntohs(clientaddr.sin_port)
        );
        int len=;
        struct fileInfo file_name;
        len=Read(confd,&file_name,sizeof(file_name));
        if(len==){
            Close(confd);
        }else {
            printf("file name len=%d\n",file_name.len);
            printf("file name is %s\n",file_name.fileName);
        }
        char buf[MAXLINE];
        FILE *fp=fopen(file_name.fileName,"w");
        if(!fp){
            perror("open file failed");
            Close(confd);
            Close(listenfd);
        }
        while((len=Read(confd,buf,MAXLINE))>){
            fwrite(buf,sizeof(char),len,fp);
        }
        if(len==){
            fclose(fp);
            printf("receive file done\n");
            Close(confd);
        }
    }
    Close(listenfd);
    return ;
}

wrap.c

#include "wrap.h" 

/*********************************************************************
 * * Name      : perr_exit
 * * Description    : exit the function
 * * Input    : the error string
 * * Output    :
 * * Return    :
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
void perr_exit(const char *s)
{
    perror(s);
    exit();
} 

/*********************************************************************
 * * Name      : Accept
 * * Description    : accept a connection on a socket
 * * Input    : fd---a socket that has been created
 * * sa---a pointer to a sockaddr structure
 * * salenptr---actual size of the peer address
 * * Output    :
 * * Return    : the descriptor for the accepted socket
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    int n; 

again:
    if((n = accept(fd, sa, salenptr)) < ) {
        if((ECONNABORTED == errno) || (EINTR == errno))
            goto again;
        else
            perr_exit("accept error");
    } 

    return n;
} 

/*********************************************************************
 * * Name      : Bind
 * * Description    : bind a name to a socket
 * * Input    : fd---a socket that has been created
 * * sa---a pointer to a sockaddr structure
 * * salen---the size of the address structure
 * * Output    :
 * * Return    :
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if(bind(fd, sa, salen) < )
        perr_exit("bind error");
} 

/*********************************************************************
 * * Name      : Connect
 * * Description    : initiate a connection on a socket
 * * Input    : fd---a socket that has been created
 * * sa---a pointer to a sockaddr structure
 * * salen---the size of the address structure
 * * Output    :
 * * Return    :
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if(connect(fd, sa, salen) < )
        perr_exit("connect error");
} 

/*********************************************************************
 * * Name      : Listen
 * * Description    : listen for connections on a socket
 * * Input    : fd---a socket that has been created
 * * backlog---the maximum length to the queue of
 * * pending connections
 * * Output    :
 * * Return    :
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
void Listen(int fd, int backlog)
{
    if(listen(fd, backlog) < )
        perr_exit("listen error");
} 

/*********************************************************************
 * * Name      : Socket
 * * Description    : create an endpoint for communication
 * * Input    : family---a communication domain
 * * type---the communication semantics
 * * protocol---a particular protocol for the socket
 * * Output    :
 * * Return    : return a descriptor of the socket
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
int Socket(int family, int type, int protocol)
{
    int n; 

    if((n = socket(family, type, protocol)) < )
        perr_exit("socket error");
    return n;
} 

/*********************************************************************
 * * Name      : Read
 * * Description    : read from a file descriptor
 * * Input    : fd---a socket that has been created
 * * ptr---the buffer which storage the bytes
 * * nbytes---the number of bytes read
 * * Output    :
 * * Return    : return the number of bytes read
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t n; 

again:
    if((n = read(fd, ptr, nbytes)) == -) {
        if(EINTR == errno)
            goto again;
        else
            return -;
    }    

    return n;
} 

/*********************************************************************
 * * Name      : Write
 * * Description    : write to a file descriptor
 * * Input    : fd---a socket that has been created
 * * ptr---buffer of the bytes
 * * nbytes---the number of bytes written
 * * Output    :
 * * Return    : return the number of bytes written
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
    ssize_t n; 

again:
    if((n = write(fd, ptr, nbytes)) == -) {
        if(EINTR == errno)
            goto again;
        else
            return -;
    } 

    return n;
} 

/*********************************************************************
 * * Name      : Close
 * * Description    : close a file descriptor
 * * Input    : fd---a socket that has been created
 * * Output    :
 * * Return    :
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
void Close(int fd)
{
    if(close(fd) == -)
        perr_exit("close error");
} 

/*********************************************************************
 * * Name      : Readn
 * * Description    : read from a file descriptor,
 * * make sure read the enough bytes
 * * Input    : fd---a socket that has been created
 * * ptr---the buffer which storage the bytes
 * * nbytes---the number of bytes read
 * * Output    :
 * * Return    : return the number of bytes read
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
ssize_t Readn(int fd, void *vptr, size_t nbytes)
{
    size_t nleft;
    size_t nread;
    char *ptr; 

    ptr = vptr;
    nleft = nbytes; 

    while(nleft > ) {
        if((nread = read(fd, ptr, nleft)) < ) {
            if(EINTR == errno)
                nread = ;
            else
                return -;
        } else if(nread == )
            break; 

        nleft -= nread;
        ptr += nread;
    } 

    return (nbytes-nleft);
} 

/*********************************************************************
 * * Name      : Writen
 * * Description    : write to a file descriptor,
 * * make sure write the enough bytes
 * * Input    : fd---a socket that has been created
 * * ptr---the buffer which storage the bytes
 * * nbytes---the number of bytes read
 * * Output    :
 * * Return    : return the number of bytes read
 * * Others    : by jzk 2009.12.02
 * **********************************************************************/
ssize_t Writen(int fd, const void *vptr, size_t nbytes)
{
    size_t nleft;
    size_t nwritten;
    const char *ptr; 

    ptr = vptr;
    nleft = nbytes; 

    while(nleft > ) {
        if((nwritten = write(fd, ptr, nleft)) <= ) {
            if(nwritten <  && EINTR == errno)
                nwritten = ;
            else
                return -;
        } 

        nleft -= nwritten;
        ptr += nwritten;
    } 

    return nbytes;
}

static ssize_t my_read(int fd,char *ptr)
{
    static int read_cnt;
    static char *read_ptr;
    static char read_buf[];

    if(read_cnt<=){
again:
        if((read_cnt=read(fd,read_buf,sizeof(read_buf))<)){
            if(errno==EINTR)
                goto again;
                return -;
        }else if(read_cnt==)
            return ;
        read_ptr=read_buf;
    }
    read_cnt--;
    *ptr=*read_ptr++;
    return ;
}
size_t Read_line(int fd,void *vptr,size_t maxlen)
{
    ssize_t n,rc;
    char c,*ptr;

    ptr=vptr;
    for(n=;n<maxlen;n++){
        if((rc=my_read(fd,&c))==){
            *ptr++=c;
            if(c=='\n')
                break;
        }else if(rc==){
            *ptr=;
            return n-;
        }else
             return -;
    }
    *ptr=;
    return n;
}

wrap.h

#ifndef WRAP_H
#define WRAP_H 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h> 

void perr_exit(const char *s); 

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
void Bind(int fd, const struct sockaddr *sa, socklen_t salen);
void Connect(int fd, const struct sockaddr *sa, socklen_t salen);
void Listen(int fd, int backlog); 

int Socket(int family, int type, int protocol);
void Close(int fd); 

ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes); 

ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n); 

ssize_t Readline(int fd, void *vptr, size_t maxlen); 

#endif 

Makefile

######################################
#
#######################################
#source file
#源文件，自动找所有.c和.cpp文件，并将目标定义为同名.o文件
SOURCE  := $(wildcard *.c) $(wildcard *.cpp)
OBJS    := $(patsubst %.c,%.o,$(patsubst %.cpp,%.o,$(SOURCE)))

#target you can change test to what you want
#目标文件名，输入任意你想要的执行文件名
TARGET  := client server
APP1    := client
APP2    := server

MAINS    :=$(APP1).o $(APP2).o
#compile and lib parameter
#编译参数
CC      := gcc
LIBS    := -lpthread -lrt
LDFLAGS :=
DEFINES :=
INCLUDE := -I.
CFLAGS  := -g -Wall -O3 $(DEFINES) $(INCLUDE)
CXXFLAGS:= $(CFLAGS) -DHAVE_CONFIG_H

#i think you should do anything here
#下面的基本上不需要做任何改动了
.PHONY : everything objs clean veryclean rebuild

everything : $(TARGET)

all : $(TARGET)

objs : $(OBJS)

rebuild: veryclean everything

clean :
    rm -fr *.so
    rm -fr *.o

veryclean : clean
    rm -fr $(TARGET)

$(APP1) :$(APP1).o $(filter-out $(MAINS), $(OBJS))
    $(CC)  $(CXXFLAGS) -o $@ $^  $(LDFLAGS) $(LIBS)
$(APP2) :$(APP2).o $(filter-out $(MAINS), $(OBJS))
    $(CC)  $(CXXFLAGS) -o $@ $^  $(LDFLAGS) $(LIBS)