/*
*
should use evbuffer_free(evb); to free this evbuffer
* */
static struct http_response * http_req(char * ip, int port, char * verb, char * path, char * data){
char port_str[6];
sprintf(port_str, "%d", port);
int cs = client_socket(ip, port_str);
char * request_buffer = alloca(100 + strlen(path)); // in stack do not need free
char response_buffer[1024*8];
sprintf(request_buffer, "%s %s HTTP/1.0\r\nContent-Length: %d\r\n\r\n%s\r\n\r\n", verb, path, strlen(data), data);
//sprintf(request_buffer, "GET %s HTTP/1.0\r\nUser-Agent: curl/7.19.7 (i486-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n\r\n", path);
fprintf(stderr, "%s", request_buffer);
int rst = tcptowrite(cs, request_buffer, strlen(request_buffer) , 30000);
printf("tcptowrite rst: %d", rst);
int readed = 0;
struct evbuffer *evb = evbuffer_new();
/*evbuffer_read(evb, cs, 30);*/
while ((readed = tcptoread(cs, response_buffer, 1024*8, 30000)) > 0){
printf("readed len: %d \n", readed);
evbuffer_add(evb, response_buffer, readed);
}
struct evbuffer_ptr evbptr = evbuffer_search(evb, "\r\n\r\n", 4, NULL);
struct evbuffer *headers = evbuffer_new();
evbuffer_remove_buffer(evb, headers, evbptr.pos);
/*evbuffer_drain(evb, evbptr.pos);*/
tcpclose(cs);
int code = parse_response_status_code(headers);
return http_response_new(code, headers, evb);
}
static inline int32_t mainserv_towrite(int sock,const uint8_t *ptr,uint32_t leng,uint32_t timeout) {
int32_t r;
r = tcptowrite(sock,ptr,leng,timeout);
if (r>0) {
mainserv_bytesout(r);
}
return r;
}
int client()
{
int cs = client_socket("127.0.0.1", "9991");
tcptowrite(cs, "helloworl", 10, 1000);
/*printf("write ok %d \n", n); */
tcpclose(cs);
return 0;
}
int client(){
int cs = client_socket("127.0.0.1", "9991");
uint8_t buffer [10000];
mc_mkdir_request * req = create_mkdir_request();
int len = mc_mkdir_request_pack(req, buffer, 10000);
printf("tcptowrite %d", len);
if (tcptowrite(cs, buffer, len, 1000) <= 0)
perror("error on tcptowrite");
/*printf("write ok %d \n", n);*/
tcpclose(cs);
return 0;
}
static void* masterproxy_server(void *args) {
uint8_t header[8];
uint8_t querybuffer[QUERYSIZE];
uint8_t ansbuffer[ANSSIZE];
uint8_t *wptr;
const uint8_t *rptr;
int sock = *((int*)args);
uint32_t psize,cmd,msgid,asize,acmd;
free(args);
for (;;) {
if (tcptoread(sock,header,8,1000)!=8) {
tcpclose(sock);
return NULL;
}
rptr = header;
cmd = get32bit(&rptr);
psize = get32bit(&rptr);
if (cmd==CLTOMA_FUSE_REGISTER) { // special case: register
// if (psize>QUERYSIZE) {
if (psize!=73) {
tcpclose(sock);
return NULL;
}
if (tcptoread(sock,querybuffer,psize,1000)!=(int32_t)(psize)) {
tcpclose(sock);
return NULL;
}
if (memcmp(querybuffer,FUSE_REGISTER_BLOB_ACL,64)!=0) {
tcpclose(sock);
return NULL;
}
if (querybuffer[64]!=REGISTER_TOOLS) {
tcpclose(sock);
return NULL;
}
wptr = ansbuffer;
put32bit(&wptr,MATOCL_FUSE_REGISTER);
put32bit(&wptr,1);
put8bit(&wptr,STATUS_OK);
if (tcptowrite(sock,ansbuffer,9,1000)!=9) {
tcpclose(sock);
return NULL;
}
} else {
if (psize<4 || psize>QUERYSIZE) {
tcpclose(sock);
return NULL;
}
if (tcptoread(sock,querybuffer,psize,1000)!=(int32_t)(psize)) {
tcpclose(sock);
return NULL;
}
rptr = querybuffer;
msgid = get32bit(&rptr);
asize = ANSSIZE-12;
if (fs_custom(cmd,querybuffer+4,psize-4,&acmd,ansbuffer+12,&asize)!=STATUS_OK) {
tcpclose(sock);
return NULL;
}
wptr = ansbuffer;
put32bit(&wptr,acmd);
put32bit(&wptr,asize+4);
put32bit(&wptr,msgid);
if (tcptowrite(sock,ansbuffer,asize+12,1000)!=(int32_t)(asize+12)) {
tcpclose(sock);
return NULL;
}
}
}
}
uint32_t direct_writeblock(const char *src_path, uint64_t chunkid, uint64_t *t_size)
{
uint8_t *ptr = NULL;
uint8_t *ibuff = NULL;
int8_t status = 0;
uint64_t size;
uint64_t len;
uint32_t read_size = 0;
FILE *fp = NULL;
char *p_data = NULL;
fp = fopen(src_path, "rb");
if (fp == NULL) {
fprintf(stderr, "open file(%s) failed!\n", src_path);
return 3;
}
size = get_file_size(src_path);
if (size <= 0) { // 大小为0的文件丢弃
fprintf(stderr, "get file(%s) error!\n", src_path);
fclose(fp);
return 3;
}
ibuff = malloc(24);
ptr = ibuff;
PUT32BIT(DRWTODAT_WRITE_INFO, ptr);
PUT32BIT(16, ptr);
PUT64BIT(chunkid, ptr);
PUT64BIT(size,ptr);
if (tcptowrite(rw_sock, ibuff, 24, CSMSECTIMEOUT) != 24) {
free(ibuff);
fclose(fp);
fprintf(stderr, "write data to dat error!\n");
return 3;
}
free(ibuff);
// 等待dat端的回复
uint8_t hdr[13];
uint8_t *ptr1 = NULL;
uint32_t cmd1 = 0;
uint32_t len1 = 0;
uint32_t version1 = 0;
ptr1 = hdr;
if (read(rw_sock, hdr, 13) != 13) {
fprintf(stderr, "read data from dat error\n");
}
GET32BIT(cmd1, ptr1);
GET32BIT(len1, ptr1);
GET32BIT(version1, ptr1);
GET8BIT(status, ptr1);
int i = 0;
for(i=0; i< 13; i++) {
fprintf(stderr, "%u-", hdr[i]);
}
fprintf(stderr, "hdr end\n");
if (cmd1 != DATTODRW_WRITE_INFO || status != 0) {
fprintf(stderr, "dat not ready!\n");
return 1;
}
ibuff = malloc(W_PACK_SIZE*sizeof(uint8_t));
ptr = ibuff;
p_data = malloc(W_PACK_SIZE*sizeof(char));
len = 0;
while (len < size) {
read_size = fread(p_data, sizeof(char), W_PACK_SIZE, fp);
if (read_size < 0) {
fprintf(stderr, "fread file(%s) error!\n", src_path);
fclose(fp);
free(ibuff);
free(p_data);
return 3;
}
memcpy(ptr, p_data, read_size);
if (tcptowrite(rw_sock, ibuff, read_size, CSMSECTIMEOUT) != read_size) {
fprintf(stderr, "readblock; tcpwrite error!\n");
free(ibuff);
free(p_data);
fclose(fp);
return 3;
}
if (DEBUG) {
fprintf(stderr, "total size(%llu), read size: %llu\n",
(unsigned long long int)size, (unsigned long long int)len);
}
len += read_size;
}
fprintf(stderr, "Write over!\n");
*t_size = size;
fclose(fp);
free(ibuff);
free(p_data);
return status;
}
