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

协议啥的都在上一篇日志《基于libevent2.0的ministored的http框架--server端》说啦，client短还是废话少说，直接上代码吧！

包含了put和get的操作以及部分的测试代码，gcc下编译可以直接通过！

#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;
}