socket客户端

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <stdarg.h>

#define MAXTIME 1024
//#define SER_IP "169.254.130.128" /*服务器的IP地址*/
#define SER_IP "192.168.152.128" /*服务器的IP地址*/

int read_socket(int socket_id, char *pbuf, int len);
int write_socket(int socket_id, char *pbuf, int len);

int main(int argc, char ** argv) /*客户端程序*/
{

    fd_set readset;
    fd_set writeset;
    int txtfd;
    int maxfdp;

    char judg[32];
    char readbuf[1024];
    char total_buf[1024];
    int sockfd = -1;
    int ret = -1;
    int opt = 1;
    int len1, len2;
    struct sockaddr_in seraddr; /*用来存放要访问的服务器的IP地址和端口号*/
    //struct timeval timeout={3,0};

    struct timeval timeout;
    timeout.tv_sec=5;
    timeout.tv_usec=0;

    memset(judg, 0, sizeof(judg));
    memset(readbuf, 0, sizeof(readbuf));
    memset(total_buf, 0, sizeof(total_buf));
    memset(&seraddr, 0, sizeof(seraddr)); /*初始化*/

    txtfd = open("./select.txt", O_RDWR);
    if(txtfd < 0)
    {
            printf("open err!\n");
            exit(-1);
    }

    sockfd = socket(AF_INET, SOCK_STREAM, 0); /*创建套接字文件,TCP协议*/
    if(sockfd < 0)
    {
        return -1;
    }

    seraddr.sin_family = AF_INET; /*服务器的地址族协议*/
    seraddr.sin_port = htons(4989);     /*服务器的端口号*/
    inet_pton(AF_INET, SER_IP, &seraddr.sin_addr.s_addr); /*服务器的ip地址*/

    ret = connect_retry(sockfd, (struct sockaddr*)&seraddr, sizeof(seraddr)); /*请求连接服务器*/
    if(ret < 0)
    {
        printf("connect_retry err!\n");
        return -1;
    }

    printf("客户端已请求连接！\n");

    char    serv_ip[20];
    char    guest_ip[20];
  struct sockaddr_in serv;
  struct sockaddr_in guest;
  socklen_t serv_len = sizeof(serv);
  socklen_t guest_len = sizeof(guest);

  getsockname(sockfd, (struct sockaddr *)&guest, &guest_len);
  getpeername(sockfd, (struct sockaddr *)&serv, &serv_len);

  inet_ntop(AF_INET, &guest.sin_addr, guest_ip, sizeof(guest_ip));
  inet_ntop(AF_INET, &serv.sin_addr, serv_ip, sizeof(serv_ip));
  printf("服务端IP和PORT[%s]:[%d]\n", serv_ip, ntohs(serv.sin_port));
  printf("客户端IP和PORT[%s]:[%d]\n", guest_ip, ntohs(guest.sin_port));

  printf("close(sockfd) begin:\n");
  write(sockfd, "wangxc", strlen("wangxc"));
  //close(sockfd);
  printf("close(sockfd) ok!\n");
    while(1);

    while(1)
    {
            printf("***********************************************\n");

            sleep(5);
            FD_ZERO(&readset);
            FD_ZERO(&writeset);

            FD_SET(sockfd, &readset); //添加描述符
            FD_SET(txtfd, &readset); //添加描述符
            FD_SET(sockfd, &writeset); //添加描述符
            FD_SET(txtfd, &writeset); //添加描述符

            maxfdp = sockfd > txtfd ? sockfd+1 : txtfd+1;
            printf("sockfd=[%d]\n", sockfd);
            printf("txtfd=[%d]\n", txtfd);
            printf("maxfdp=[%d]\n", maxfdp);

            ret = select(maxfdp, &readset, &writeset, NULL, &timeout);
            printf("select ret = [%d]\n", ret);
            switch(ret)
            {
                    case 0:
                    {
                            printf("已经超时，没有描述符准备好！\n");
                            break; //再次轮循
                    }
                    case (-1):
                    {
                            printf("select err!\n");
                            exit(-1);
                    }
                    default:
                    {
                            ret = FD_ISSET(sockfd, &readset);
                            printf("FD_ISSET ret=[%d]\n", ret);
                            if(ret == 1) //sockfd读准备好:即网络上有数据
                            {
                                        printf("sockfd 可读！\n");
                                        memset(readbuf, 0, sizeof(readbuf));
                                        read(sockfd, readbuf, sizeof(readbuf)); /*对服务器是否准备好的判断*/
                                        printf("客户端接受数据：[%s]\n", readbuf);
                                        ret = FD_ISSET(txtfd, &writeset);
                                        if(ret == 1)
                                        {
                                                write(txtfd, readbuf, strlen(readbuf));
                                        }
                            }
                            else //sockfd读没准备好:即网络上还没有数据
                            {
                                    printf("sockfd 读会阻塞！\n");
                            }

                            ret = FD_ISSET(sockfd, &writeset);
                            printf("FD_ISSET ret=[%d]\n", ret);
                            if(ret == 1) //sockfd写准备好
                            {
                                        printf("sockfd 可写！\n");
                            }
                            ret = FD_ISSET(txtfd, &readset);
                            printf("FD_ISSET ret=[%d]\n", ret);
                            if(ret == 1)
                            {
                                        printf("txtfd 可读！\n");
                            }
                            ret = FD_ISSET(txtfd, &writeset);
                            printf("FD_ISSET ret=[%d]\n", ret);
                            if(ret == 1)
                            {
                                        printf("txtfd 可写！\n");
                            }
                    }
            }

    }

    close(sockfd);
    return 0;
}



/***********************************************************
* 函 数 名：connect_retry
* 功能描述: 瞬时connect错误,支持重试的连接
* 输入参数：
* 输出参数：
* 返    回：
* 流程描述：
* 说明：
* 修改记录:
* [修改人] [日期] - [描述]
***********************************************************/
int connect_retry(int sockfd, const struct sockaddr * addr, socklen_t len)
{
    int time;
    for(time = 1; time <= MAXTIME; time <<= 1)
    {
        if(connect(sockfd, addr, len) == 0)
        {
            return 0;
        }
        if(time <= MAXTIME/2)
        {
            printf("connect失败，睡眠[%d]秒\n", time);
            sleep(time);
        }
    }
    return -1;
}


/***********************************************************
* 函 数 名：read_socket
* 功能描述: 读socket
* 输入参数：
* 输出参数：
* 返    回：
* 流程描述：
* 说明：
* 修改记录:
* [修改人] [日期] - [描述]
***********************************************************/
int read_socket(int socket_id, char *pbuf, int len){
    int num;
    int i;

    if(len <= 0) {
        return     read(socket_id, pbuf, sizeof(pbuf));
    }

    i = 0;
    do{
        num = read(socket_id, &(pbuf[i]), len - i);
        if (num <= 0){
            /* LOG: Read socket error exit. */
            return(-1);
        }
        i += num;
    } while (i < len);

    return(i);
}

/***********************************************************
* 函 数 名：write_socket
* 功能描述: 写socket
* 输入参数：
* 输出参数：
* 返    回：
* 流程描述：
* 说明：
* 修改记录:
* [修改人] [日期] - [描述]
***********************************************************/
int write_socket(int socket_id, char *pbuf, int len){
    int num;
    int i;

    if (len <= 0) return(0);

    i = 0;
    do{
        num = write(socket_id, &(pbuf[i]), len - i);
        if (num < 0){
            /* LOG: Write socket error exit. */
            return(-1);
        }
        i += num;
    } while (i < len);

    return(i);
}