如果使用socket发送http请求（并且编译成可以被lr调用的压力测试脚本）

#include  <unistd.h>
#include  <sys/types.h>       /* basic system data types */
#include  <sys/socket.h>      /* basic socket definitions */
#include  <netinet/in.h>      /* sockaddr_in{} and other Internet defns */
#include  <arpa/inet.h>       /* inet(3) functions */
#include <netdb.h> /*gethostbyname function */
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>


#include<openssl/rsa.h>
#include<openssl/pem.h>
#include<openssl/err.h>
#define OPENSSLKEY "/test.key"
#define PUBLICKEY "/test_pub.key"
#define BUFFSIZE 1024
#define MAXLINE 10240


char *my_encrypt(char *str,char *path_key){
    char *p_en;
    RSA *p_rsa;
    FILE *file;
    int flen,rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;    
    }   
    if((p_rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==NULL){
    //if((p_rsa=PEM_read_RSAPublicKey(file,NULL,NULL,NULL))==NULL){   换成这句死活通不过，无论是否将公钥分离源文件
        ERR_print_errors_fp(stdout);
        return NULL;
    }   
    flen=strlen(str);
    rsa_len=RSA_size(p_rsa);
    p_en=(unsigned char *)malloc(rsa_len+1);
    memset(p_en,0,rsa_len+1);
    if(RSA_public_encrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_en,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }   
    RSA_free(p_rsa);
    fclose(file);
    return p_en;
}
char *my_decrypt(char *str,char *path_key){
    char *p_de;
    RSA *p_rsa;
    FILE *file;
    int rsa_len;
    if((file=fopen(path_key,"r"))==NULL){
        perror("open key file error");
        return NULL;
    }
    if((p_rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==NULL){
        ERR_print_errors_fp(stdout);
        return NULL;
    }
    rsa_len=RSA_size(p_rsa);
    p_de=(unsigned char *)malloc(rsa_len+1);
    memset(p_de,0,rsa_len+1);
    if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_de,p_rsa,RSA_NO_PADDING)<0){
        return NULL;
    }
    RSA_free(p_rsa);
    fclose(file);
    return p_de;
}
EVP_PKEY * getKey(char * key_path) {
    X509 *cert = NULL;
    BIO *in = NULL;
    EVP_PKEY *key;


    in = BIO_new_file(key_path, "r");
    cert = PEM_read_bio_X509(in, NULL, NULL, NULL);
    if (cert != NULL) {
        key = (EVP_PKEY *) X509_get_pubkey(cert);
    } else {
        in = BIO_new_file(key_path, "r");
        key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
    }
    BIO_free(in);
    if (cert) {
        X509_free(cert);
    }
    return key;
}


char *my_encrypt2(unsigned char *str,int * plen){
    int cryptedlen;
    unsigned char *cryptedbuf;
    int i=0;
    EVP_PKEY *key;
    key = getKey(PUBLICKEY);

    *plen = EVP_PKEY_size(key);
    cryptedbuf = malloc((*plen) + 1);
    memset(cryptedbuf,0,(*plen)+ 1);


    if(RSA_public_encrypt(strlen(str),(unsigned char *)str,cryptedbuf,key->pkey.rsa,RSA_PKCS1_PADDING)<0){
       return NULL;
   }
    EVP_PKEY_free(key);
    for(i=0;i<128;i++) {
       printf(" %d ", (unsigned char)cryptedbuf[i]);
     }
      printf("\n");
    return cryptedbuf;
}
  


int opensocket(char *ip,int port)
{
  int connfd;
  char * servInetAddr = ip;
  int servPort = port;
  char dataBuffer[MAXLINE];
  struct sockaddr_in servaddr;
  //设置超时时间
  struct timeval timeout={30,0};//3s

  //connfd = socket(AF_INET, SOCK_STREAM, 0);
   if ((connfd=socket(AF_INET,SOCK_STREAM,0))== -1)
    {
        perror("socket");
        return 0;
    }


   if (setsockopt(connfd,SOL_SOCKET,SO_SNDTIMEO,(const char*)&timeout,sizeof(timeout)) == -1)
    {
        perror("setsockopt");
       return 0;
    }


  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_port = htons(servPort);
  inet_pton(AF_INET, servInetAddr, &servaddr.sin_addr);
 


  if (connect(connfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) {
        perror("connect error");
        return -1;
   }


  else{
       //return 1;
       return connfd;
   }
}


void closesocket(int connfd){
close(connfd);
}

int  msgsend(int connfd,char *msg, int len){
char dataBuffer[MAXLINE];
bzero(dataBuffer,MAXLINE+1);
strncpy(dataBuffer,msg,strlen(msg));
int errSend = send(connfd,dataBuffer,len,0);
if(-1 == errSend)
      {
        return -1;
      }else{
return 1;
}
}


//对rsa加密后的数据进行发送
int rsa_msgsend(int connfd,char * source)
{
    char *ptr_en,*ptr_de;
    char send_msg[1024];
    int plen=0;
    ptr_en=my_encrypt2(source,&plen);
    char head[150];
    sprintf(head, "POST /auth HTTP/1.1\r\nHost: bjcm01.portal.freemse.360.cn\r\nAccept-Version: 1\r\nAppId:1\r\nUser-Agent:MSE 8.0.0;Android 5.0\r\nContent-Length: %d\r\n\r\n", plen);
    printf("plen :%d \n",plen);
   // printf("source is    :%s\n",start);
    //ptr_de=my_decrypt(ptr_en,OPENSSLKEY);
    //printf("jiemi data %s\n",ptr_de);
    //sprintf(send_msg,"%s%s",start,ptr_en);
    //printf("send_msg %s\n",start);
   int h_send_result = msgsend(connfd,head, strlen(head));
   printf("head: %s\n",head);
   int b_send_result =  msgsend(connfd,ptr_en, plen);
   printf("ptr_en: %s\n",ptr_en);
   if( h_send_result == -1 || b_send_result == -1){
    return -1;
   }
   else{
     return 1;
    }
}


//对比返回的结果
int cmprecvmsg(int connfd,char *msg,int len){
        char dataBuffer[MAXLINE];
        bzero(dataBuffer,MAXLINE+1);
        int recv_bytes = recv(connfd,dataBuffer,MAXLINE,0);
        //return dataBuffer;        
        if(recv_bytes < 0)
        {
             return -2;
        }


        if(memcmp(dataBuffer,msg,len)==0){
                return 1;
        }else{
                return -1;
        }

}



int gettimeofday(struct timeval *tv, struct timezone *tz);
int httpSendAndRcv(int sockfd,char *realhost){
         struct timeval t_start,t_end;
         long cost_time = 0;
         #define BUFSIZE 1024
        int ret, i,j, h;
        struct sockaddr_in servaddr;
        char str1[4096], str2[4096], buf[BUFSIZE];
        socklen_t len;
        fd_set   t_set1;
        struct timeval timeout={5,0}; //select等待5秒，5秒轮询，要非阻塞就置0 


        //发送数据
        memset(str1, 0, 4096);//一定要初始化一下该内存，因为在测试时发现发送的字符串有一些脏数据

        strcat(str1, "GET / HTTP/1.1\n");
        strcat(str1, "Host: test.com\r\n");
        strcat(str1, "RealHost:");
        strcat(str1, realhost);
        strcat(str1, "\r\n");
        strcat(str1, "Content-Type: application/x-www-form-urlencoded");
        strcat(str1, "\r\n\r\n");
        printf("%s\n",str1);
                
         gettimeofday(&t_start, NULL);
 
         long start = ((long)t_start.tv_sec)*1000+(long)t_start.tv_usec/1000;//为了获取毫秒的时间，只有将秒和微妙都转成毫秒来计算了
         printf("Start time: %ld ms\n", start);
               ret = write(sockfd,str1,strlen(str1));


               if (ret < 0) {
                    printf("发送失败！错误代码是%d，错误信息是‘%s‘\n",errno, strerror(errno));
                    exit(0);
                }else{
                    printf("消息发送成功，共发送了%d个字节！\n\n", ret);
                }
                while(1){
                   //sleep(1);
                   FD_ZERO(&t_set1);
                   FD_SET(sockfd, &t_set1);
                   h= 0;
                  // printf("--------------->1");
                   h= select(sockfd +1, &t_set1, NULL, NULL, &timeout);
                   //printf("--------------->2");

                   if (h == 0) break;  //如果在超时时间内没有数据返回认为http的response接受完毕，可以进行下一轮请求
                   if (h < 0) {
                        close(sockfd);
                        printf("在读取数据报文时SELECT检测到异常，该异常导致线程终止！\n");
                        return -1;
                };

                if (h > 0){
                        memset(buf, 0, 4096);
                        i= read(sockfd, buf, 4095);
                        if (i==0){
                                close(sockfd);
                                printf("读取数据报文时发现远端关闭，该线程终止！\n");
                                return -1;
                        }
                          // printf("recive");
                          printf("%s\n", buf);
                }
           }
       
       //获取结束时间
       gettimeofday(&t_end, NULL);
       long end = ((long)t_end.tv_sec)*1000+(long)t_end.tv_usec/1000;
       printf("End time: %ld ms\n", end);
       //统计网页响应的时间差（当然包括了一次超时时间）
       cost_time = end - start;
       printf("Cost time: %ld ms\n", cost_time);
       
       return 0;
}


//测试用
int main()
{
    //unsigned char *source="{\"phone\":\"10002415407\", \"token\":\"47\", \"wid\":\"1\"}";
     char *source="{\"phone\":\"1212121212\", \"token\":\"121212121\", \"wid\":\"wid\"}";
    //char *ptr_en,*ptr_de;
    char *ip="127.0.0.1";
    int port=80
    int connfd;
    char buf[20]; 
    char buf1[5]; 
    char * realhost="m.so.com";
    // char send_msg[1024];
    char dataBuffer[21700];
    int j;
    //int plen=0;
    //ptr_en=my_encrypt2(source,&plen);
    //char start[150];
    //sprintf(start, "POST /auth HTTP/1.1\r\nHost: bjcm01.portal.freemse.360.cn\r\nAccept-Version: 1\r\nUser-Agent:MSE 8.0.0;Android 5.0\r\nContent-Length: %d\r\n\r\n", plen);
    //printf("plen :%d \n",plen);
   // printf("source is    :%s\n",start);
    //ptr_de=my_decrypt(ptr_en,OPENSSLKEY);
    //printf("jiemi data %s\n",ptr_de);
    connfd=opensocket(ip,port);
    //sprintf(send_msg,"%s%s",start,ptr_en);
    //printf("send_msg %s\n",start);
   // msgsend(connfd,start, strlen(start));
    //msgsend(connfd,ptr_en, plen);
    rsa_msgsend(connfd,source);
    recv(connfd,dataBuffer,21700,0);
    sscanf(dataBuffer, "%*[^\"]%[^m]", buf); 
    sscanf(buf, "%*[^:]:%[^,]", buf1); 
    printf("recv %s\n",dataBuffer);
    printf("%s\n",buf1);
    for (j=0;j<3;j++) msgrecv(connfd,realhost);
    closesocket(connfd);
    return 0;
}