linux网络编程笔记——TCP

1、TCP和UDP

TCP是长连接像持续的打电话，UDP是短消息更像是发短信。TCP需要消耗相对较多的资源，但是传输质量有保障，UDP本身是不会考虑传输质量的问题。

2、网络传输内容

我习惯的做法是直接通过TCP传送结构体，当然前提是收发两端都在程序里对目标结构体有充分的定义。特别说明的一点是，要小心收发两端处理器的大小端问题！而且传输信息头里必须包含长度信息，而且通用的是大端。但是，这里的长度和结构体，我选择用小端进行传输。

3、TCPserver实现

参考了别人多线程的回调写法，看起来不错。

tcputil.c（照搬别人的，文件内有作者信息）

 /**************************************************
  *
  * $description: collection of functions
  * $author: smstong
  * $date: Tue Apr 16 10:24:22 CST 2013
  *
  * ************************************************/
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <pthread.h>
 /**************************************************
  * func: receive n bytes from socket except an error
  * params: fd - socket handle
  *            buf - memory space to write
  *            n - size of buf
  * return: -1 - error;
  *            >=0 - actually retceived bytes
  *************************************************/
 ssize_t recvn(int fd, void* buf, size_t n)
 {
     char* ptr = (char*)buf; // position pointer
     size_t left = n;        // bytes left to read
     while(left > ) {
         size_t nread = read(fd, ptr, left);
         if(nread<)  {
             if(errno==EINTR) { // an error occured
                 nread = ;
             } else {
                 return -;
             }
         } else if(nread==) { //normally disconnect, FIN segment received
             break;
         } else {
             left -= nread;
             ptr += nread;
         }
     }
     return (n-left);
 }
 
 /********************************************************
  * function: write n bytes to socket except error
  * params: fd - socket hanle
  *            buf - src memory
  *            n - bytes to write
  * return: -1 - error
  *            >=0 - bytes actually written
  * ******************************************************/
 ssize_t writen(int fd, void* buf, size_t n)
 {
     char* ptr = (char*)buf;
     size_t left = n;
     while(left > ) {
         size_t nwrite = write(fd, ptr,left);
         if(nwrite<) {
             if(errno==EINTR) {
                 nwrite = ;
             } else {
                 return -;
             }
         } else if(nwrite==) {
             break;
         } else {
             left -= nwrite;
             ptr += nwrite;
         }
     }
     return (n-left);
 }
 
 static void * thread_f(void *); //thread function
 typedef int (*message_handler)(int, void *, uint32_t); // callback function called after received one message
 
 /*************************************************************
  *
  * one thread per connection frameset
  *
  * ***********************************************************/
 
 // thread function's args
 struct thread_arg {
     int socket;
     message_handler msg_handler;
 };
 
 int start(uint32_t listenip, uint16_t listenport, message_handler handler)
 {
     int    listenfd, connfd;
     struct sockaddr_in     servaddr;
     char    buff[];
     int     n;
 
     if( (listenfd = socket(AF_INET, SOCK_STREAM, )) == - ){
         printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
         exit();
     }
 
     memset(&servaddr, , sizeof(servaddr));
     servaddr.sin_family = AF_INET;
     servaddr.sin_addr.s_addr = htonl(listenip);
     servaddr.sin_port = htons(listenport);
 
     if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -){
         printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
         return -;
     }
 
     if( listen(listenfd, ) == -){
         printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
         return -;
     }
 
     printf("======waiting for client's request======\n");
     while(){
         if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -){
             printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
             continue;
         }
         /* create a new thread to handle this connection */
         pthread_t tid = ;
         int rc = ;
         struct thread_arg *parg = malloc(sizeof(struct thread_arg));
         if(NULL==parg) {
             printf("error malloc: %s\n", strerror(errno));
             return -;
         }
         parg->socket = connfd;
         parg->msg_handler = handler;
         if( != (rc=pthread_create(&tid, NULL, thread_f, parg))) {
             printf("%s: %s\n", __func__, strerror(rc));
         }
         printf(" create thread %u to handle connection %d \n", tid, connfd);
     }
     close(listenfd);
     return ;
 }
 /***************************
  * fun: receive one message
  * params: connfd - socket handle
  * return: 0 - success;
  *            -1 - error
  *
  * **************************/
 static int recv_one_message(int connfd, message_handler post_recv_one)
 {
     uint32_t msg_len = ;         /* message length */
 
     /* recv length */
     if( != recvn(connfd, &msg_len, )) { // something wrong
         return -;
     }
 
                 /*很重要的函数，内存*/
     //msg_len = ntohl(msg_len);
 
     /* recv body */
     if(msg_len > 0x7FFFFFFF) {
         printf("message body to large%d\n",msg_len);
         return -;
     }
 
     char* buf = malloc(msg_len);/* allocate memory for message body*/
     if(NULL == buf) {
         printf("%s: malloc failed!\n", __func__);
         return -;
     }
 
     if(msg_len != recvn(connfd, buf, msg_len)) {
         free(buf);
         return -;
     }
 
     if(!=post_recv_one(connfd, buf, msg_len)) { // callback
         free(buf);
         return -;
     }
 
     free(buf);
     return ;
 }
 /* thread to handle a connection */
 static void * thread_f(void * arg)
 {
     printf(" enter thread %u\n", pthread_self());
     struct thread_arg targ = *((struct thread_arg*)arg);
     int connfd = targ.socket;
     message_handler post_recv_one = targ.msg_handler;
     free(arg);
 
     int i = ;
     while() {
         if( != recv_one_message(connfd, post_recv_one)) {
             break;
         }
         printf("%d message : %d\n",connfd,i++);
     }
     close(connfd);
     printf(" leave thread %u\n", pthread_self());
 }

tcputil.h

#ifndef TCPUTIL_H
#define TCPUTIL_H
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
//结构体在内存里紧凑排列
#pragma pack(1)
typedef struct {        /* raw data */
    double tow;    // GPS time of the week in second
    unsigned char numGps;
    unsigned char numBds;
    unsigned char numGln;
    unsigned char system[MAXSAT];    // system, 0, 1, 2 GPS, BDS & GLN
    unsigned char PRN[MAXSAT];    // PRN number
    double dDO[MAXSAT];    // Doppler in Hz
    double dPR[MAXSAT];    // pseudorange in meter
} diff_t;
#pragma pack()
 
ssize_t writen(int fd, void* buf, size_t n);
ssize_t recvn(int fd, void* buf, size_t n); 
 
/*callback function called after received one message, 0-success, -1-error*/
typedef int (*message_handler)(int socket, void * buf, uint32_t size);
 
int start(uint32_t listenip, uint16_t listenport, message_handler handler);
 
#endif

server.c

#include "tcputil.h"
 
diff_t *diff;
 
/* callback called after one message received. */
int msg_handler(int fd, void* buf, uint32_t n)
{
    if (!strncmp(buf,"\nrover\n",strlen("\nrover\n")))
    {
        writen(fd, (char *)diff, sizeof(diff_t));
        printf("\t\tsend\n\n");
    }
    if (!strncmp(buf,"\nstation\n",strlen("\nstation\n")))
    {
        memcpy((char *)diff, buf+strlen("\nstation\n"), sizeof(diff_t));
        printf("\t\tupdate\n\n");
    }
 
    return ;
}
 
int main(int argc, char** argv)
{
    diff=malloc(sizeof(diff_t));
    bzero(diff,sizeof(diff_t));
    start(,PORT, msg_handler);
    free(diff);
}

4、TCPclient实现

略粗糙，将就着看吧

rover.c

#include "tcputil.h"
 
int main(int argc, const char *argv[])
{
    diff_t *diff=malloc(sizeof(diff_t));
    bzero(diff,sizeof(diff_t));
 
    struct sockaddr_in addr;
    int sock;
 
    if(argc != )
    {
        fprintf(stderr,"need an IP address\n");
        return ;
    }
    memset(&addr, , sizeof(addr));
    addr.sin_family = AF_INET;
    inet_aton(argv[],&addr.sin_addr);
    addr.sin_port = htons(PORT);
    if(       (sock = socket(PF_INET, SOCK_STREAM,))     <          )
    {
        perror("socket");
    }
    if(      connect(sock, (struct sockaddr *)&addr, sizeof(addr))    )
    {
        perror("connect");
    }
    printf("Connected!\n");
    printf("I am rover!\n");
    printf("Connected to %s:%d\n", inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
 
    char tag[]="\nrover\n";
 
    uint32_t len = strlen(tag), msg_len=+strlen(tag);
 
    char *msg=malloc(msg_len);
    bzero(msg,msg_len);
 
    memcpy(msg,&len,);
    memcpy(msg+,tag,len);
 
    while(){
        sleep();
        if(write(sock,msg,msg_len) != msg_len)
        {
            perror("write");
        }
        read(sock,(char *)diff,sizeof(diff_t));
    }
 
    free(msg);
    close(sock);
    return ;
}

station.c

#include "tcputil.h"
 
int main(int argc, const char *argv[])
{
    struct sockaddr_in addr;
    int sock;
 
    diff_t *diff=malloc(sizeof(diff_t));
    bzero(diff,sizeof(diff_t));
 
    if(argc != )
    {
        fprintf(stderr,"need an IP address\n");
        return ;
    }
    memset(&addr, , sizeof(addr));
    addr.sin_family = AF_INET;
    inet_aton(argv[],&addr.sin_addr);
    addr.sin_port = htons(PORT);
    if(       (sock = socket(PF_INET, SOCK_STREAM,))     <          )
    {
        perror("socket");
    }
    if(      connect(sock, (struct sockaddr *)&addr, sizeof(addr))    )
    {
        perror("connect");
    }
    printf("Connected!\n");
    printf("I am station!\n");
    printf("Connected to %s:%d\n", inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
 
    char tag[]="\nstation\n";
 
    uint32_t len =   strlen(tag)+sizeof(diff_t);
    int  msg_len = +strlen(tag)+sizeof(diff_t);
    char *msg=malloc(msg_len);
    bzero(msg,msg_len);
 
    memcpy(msg,&len,);
    memcpy(msg+,tag,strlen(tag));
 
    while(){
        memcpy(msg++strlen(tag),diff,sizeof(diff_t));
            printf("!!!!!!!!!!!!%d\n", msg_len);
        if(write(sock,msg,msg_len) != msg_len)
        {
            perror("write");
        }
        sleep();
    }
    free(msg);
    close(sock);
    return ;
}

附上makefile一枚

all:    rover server station
 
rover:  rover.c tcputil.o
	gcc rover.c tcputil.o -o rover -lpthread
 
server: server.c tcputil.o
	gcc server.c tcputil.o -o server -lpthread
 
station:station.c tcputil.o
	gcc station.c tcputil.o -o station -lpthread
 
tcputil:tcputil.c
	gcc tcputil.c -c -lpthread
 
.PHONY: clean
 
clean:
	rm -f *.o rover server station