基于libevent2.0的ministored的http框架--client端

来源：互联网发布：易语言充值源码编辑：程序博客网时间：2024/04/30 19:49
转自：http://blog.csdn.net/sunnydogzhou/article/details/6438149
协议啥的都在上一篇日志《基于libevent2.0的ministored的http框架--server端》说啦，client短还是废话少说，直接上代码吧！
包含了put和get的操作以及部分的测试代码，gcc下编译可以直接通过！
[cpp] view plaincopy
#include <errno.h>  
#include <stdlib.h>  
#include <string.h>  
#include <event2/event.h>  
#include <event2/http.h>  
#include <event2/buffer.h>  
#include <event2/http_struct.h>  
#include "base64.h"  
struct request_context  
{  
    struct evhttp_uri *uri;  
    struct event_base *base;  
    struct evhttp_connection *cn;  
    struct evhttp_request *req;  
    struct evbuffer *buffer;  
    int ok;  
};  
static  
void request_callback(struct evhttp_request *req, void *arg);  
static  
int make_request(struct request_context *ctx , const char * method , char * output_data,int len);  
static  
void request_callback(struct evhttp_request *req, void *arg)  
{  
    struct request_context *ctx = (struct request_context *)arg;  
    struct evhttp_uri *new_uri = NULL;  
    const char *new_location = NULL;  
    /* response is ready */  
    switch(req->response_code)  
    {  
    case HTTP_OK:  
    {  
        /*  
         * Response is received. No futher handling is required. 
         * Finish 
         */  
        const char * result = evhttp_find_header(req->input_headers,"result");  
        printf("result:%s/n",result);  
        if( strcmp( result,"MINISTORED_OK") ){  
            ctx->ok =1;    
        }else{  
            ctx -> ok = 0;     
        }  
        event_base_loopexit(ctx->base, 0);  
      
        break;  
    }  
    case HTTP_MOVEPERM:  
    case HTTP_MOVETEMP:  
        break;  
    default:  
        /* FAILURE */  
        event_base_loopexit(ctx->base, 0);  
        return;  
    }  
    evbuffer_add_buffer(ctx->buffer, req->input_buffer);  
    /* SUCCESS */  
    ctx->ok = 1;  
}  
void context_free(struct request_context *ctx)  
{  
    evhttp_connection_free(ctx->cn);  
    event_base_free(ctx->base);  
    if (ctx->buffer)  
        evbuffer_free(ctx->buffer);  
    evhttp_uri_free(ctx->uri);  
    free(ctx);  
}  
struct request_context *create_context(const char *url ,const char * method, char * output_data,int len)  
{  
    struct request_context *ctx = 0;  
    ctx = calloc(1, sizeof(*ctx));  
    if (!ctx)  
        return 0;  
    ctx->uri = evhttp_uri_parse(url);  
    if (!ctx->uri)  
        return 0;  
    ctx->base = event_base_new();  
    if (!ctx->base)  
        return 0;  
    ctx->buffer = evbuffer_new();  
    make_request(ctx, method , output_data , len );  
    return ctx;  
}  
static  
int make_request(struct request_context *ctx ,const char * method, char * output_data,int len )  
{  
    /* free connections & request */  
    if (ctx->cn)  
        evhttp_connection_free(ctx->cn);  
      
    const char * host = evhttp_uri_get_host(ctx->uri);     
    int port = evhttp_uri_get_port(ctx->uri);  
    ctx->cn = evhttp_connection_base_new(  
        ctx->base, NULL,   
        host,  
        port != -1 ? port : 80);  
    ctx->req = evhttp_request_new(request_callback, ctx);  
    evhttp_add_header(ctx->req->output_headers,"method",method);  
    evbuffer_add(ctx->req->output_buffer,output_data,len);  
    evhttp_make_request(ctx->cn, ctx->req, EVHTTP_REQ_POST, "/");  
    evhttp_add_header(ctx->req->output_headers,  
                            "Host", host);  
    return 0;  
}  
struct evbuffer * ministored_put( const char * url,void* key,int key_size, void * value,int value_size){  
    char * data = (char *) malloc(sizeof(char) * (key_size + value_size +1) );  
    memset(data,'/0',key_size + value_size +1);  
    memcpy(data,key,key_size);  
    memcpy(data + key_size,value,value_size);  
      
    char * encoded_data = (char * ) malloc ( sizeof(char ) * (key_size + value_size) * 2);  
    memset( encoded_data ,'/0',(key_size + value_size) *2);  
    int encoded_len = encode( data, key_size + value_size,encoded_data);      
      
    free(data);  
    struct request_context *ctx = create_context(url,"put",encoded_data,encoded_len );  
    if (!ctx){  
        free(encoded_data);  
        return 0;  
    }  
    /* do all of the job */  
    event_base_dispatch(ctx->base);  
    struct evbuffer *retval = 0;  
    if (ctx->ok)  
    {  
        retval = ctx->buffer;  
        ctx->buffer = 0;  
    }  
      
    free(encoded_data);  
    context_free(ctx);  
    return retval;  
}  
struct evbuffer * ministored_get( const char * url,void* key,int key_size){  
    char * data = (char *) malloc(sizeof(char) * (key_size +1) );  
    memset(data,'/0',key_size +1);  
    memcpy(data,key,key_size);  
    char * encoded_data = (char * ) malloc ( sizeof(char ) * key_size  * 2);  
    memset( encoded_data ,'/0',key_size  *2);  
    int encoded_len = encode( data, key_size ,encoded_data);      
      
    struct request_context *ctx = create_context(url,"get",encoded_data , encoded_len );  
    if (!ctx)  
        return 0;  
    /* do all of the job */  
    event_base_dispatch(ctx->base);  
    struct evbuffer *retval = 0;  
    if (ctx->ok)  
    {  
        retval = ctx->buffer;  
        ctx->buffer = 0;  
    }  
    context_free(ctx);  
    return retval;  
}  
int main(int argc, char *argv[])  
{  
    const char *uri= "http://192.168.1.200:1314/";  
    long key =11111111111111L;  
    long value=22222222222L;  
    struct evbuffer *data = ministored_put(uri,&key,8,&value,8);  
    int len = -1;  
    if( NULL != data)  
        len = evbuffer_get_length(data);  
    printf("got %d bytes/n", len);  
    if (data)  
    {  
        const char *joined = evbuffer_pullup(data, -1);  
        write(1, joined, evbuffer_get_length(data));  
        evbuffer_free(data);  
    }  
    printf("================================================/n");  
    struct evbuffer *get_data = ministored_get(uri,&key,8);  
    int get_len = -1;  
    if( NULL != get_data)  
        get_len = evbuffer_get_length(get_data);  
    printf("got %d bytes/n", get_len);  
    if (get_data)  
    {  
        char *joined = evbuffer_pullup(get_data, -1);  
        write(1, joined, evbuffer_get_length(get_data));  
          
        long value ;  
        char *decoded_data = (char *) malloc (sizeof( char ) * (8+1));  
        memset(decoded_data,'/0',8+1);  
        decode(joined,get_len,decoded_data);  
        memcpy(&value,decoded_data,8);  
        printf("value:%ld/n",value);  
        free( decoded_data);  
        evbuffer_free(get_data);  
    }  
    return 0;  
}  
分享到：