matthew/The-Powder-Toy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c77c550eac
The-Powder-Toy/http.c
Simon 2b8775bc56 Current source - 38.0
2010-07-25 15:03:39 +01:00

914 lines
20 KiB
C
Executable File
Raw Blame History

/**
* Powder Toy - HTTP Library
*
* Copyright (c) 2008 - 2010 Stanislaw Skowronek.
* Copyright (c) 2010 Simon Robertshaw
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef MACOSX
#include <malloc.h>
#endif
#include <time.h>
#ifdef WIN32
#define _WIN32_WINNT 0x0501
//#include <iphlpapi.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/socket.h>
#include <netdb.h>
#endif
#include "version.h"
#include "http.h"
#include "md5.h"
#ifdef WIN32
#define PERROR SOCKET_ERROR
#define PERRNO WSAGetLastError()
#define PEAGAIN WSAEWOULDBLOCK
#define PEINTR WSAEINTR
#define PEINPROGRESS WSAEINPROGRESS
#define PEALREADY WSAEALREADY
#define PCLOSE closesocket
#else
#define PERROR -1
#define PERRNO errno
#define PEAGAIN EAGAIN
#define PEINTR EINTR
#define PEINPROGRESS EINPROGRESS
#define PEALREADY EALREADY
#define PCLOSE close
#endif
static int http_up = 0;
static long http_timeout = 15;
static int http_use_proxy = 0;
static struct sockaddr_in http_proxy;
static char *mystrdup(char *s)
{
char *x;
if(s) {
x = malloc(strlen(s)+1);
strcpy(x, s);
return x;
}
return s;
}
static int splituri(char *uri, char **host, char **path)
{
char *p=uri,*q,*x,*y;
if(!strncmp(p, "http://", 7))
p += 7;
q = strchr(p, '/');
if(!q)
q = p + strlen(p);
x = malloc(q-p+1);
if(*q)
y = mystrdup(q);
else
y = mystrdup("/");
strncpy(x, p, q-p);
x[q-p] = 0;
if(q==p || x[q-p-1]==':') {
free(x);
free(y);
return 1;
}
*host = x;
*path = y;
return 0;
}
static char *getserv(char *host)
{
char *q, *x = mystrdup(host);
q = strchr(x, ':');
if(q)
*q = 0;
return x;
}
static char *getport(char *host)
{
char *p, *q;
q = strchr(host, ':');
if(q)
p = mystrdup(q+1);
else
p = mystrdup("80");
return p;
}
static int resolve(char *dns, char *srv, struct sockaddr_in *addr)
{
struct addrinfo hnt, *res = 0;
if(http_use_proxy) {
memcpy(addr, &http_proxy, sizeof(struct sockaddr_in));
return 0;
}
memset(&hnt, 0, sizeof(hnt));
hnt.ai_family = AF_INET;
hnt.ai_socktype = SOCK_STREAM;
if(getaddrinfo(dns, srv, &hnt, &res))
return 1;
if(res) {
if(res->ai_family != AF_INET) {
freeaddrinfo(res);
return 1;
}
memcpy(addr, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);
return 0;
}
return 1;
}
void http_init(char *proxy)
{
char *host, *port;
#ifdef WIN32
WSADATA wsadata;
if(!WSAStartup(MAKEWORD(2,2), &wsadata))
http_up = 1;
#else
signal(SIGPIPE, SIG_IGN);
http_up = 1;
#endif
if(proxy) {
host = getserv(proxy);
port = getport(proxy);
if(resolve(host, port, &http_proxy))
http_up = 0;
else
http_use_proxy = 1;
free(host);
free(port);
}
}
void http_done(void)
{
#ifdef WIN32
WSACleanup();
#endif
http_up = 0;
}
#define CHUNK 4096
#define HTS_STRT 0
#define HTS_RSLV 1
#define HTS_CONN 2
#define HTS_IDLE 3
#define HTS_XMIT 4
#define HTS_RECV 5
#define HTS_DONE 6
struct http_ctx {
int state;
time_t last;
int keep;
int ret;
char *host, *path;
char *thdr;
int thlen;
char *txd;
int txdl;
struct sockaddr_in addr;
char *tbuf;
int tlen, tptr;
char *hbuf;
int hlen, hptr;
char *rbuf;
int rlen, rptr;
int chunked, chunkhdr, rxtogo, contlen, cclose;
int fd;
char *fdhost;
};
void *http_async_req_start(void *ctx, char *uri, char *data, int dlen, int keep)
{
struct http_ctx *cx = ctx;
if(!ctx) {
ctx = calloc(1, sizeof(struct http_ctx));
cx = ctx;
cx->fd = PERROR;
}
if(!cx->hbuf) {
cx->hbuf = malloc(256);
cx->hlen = 256;
}
if(!http_up) {
cx->ret = 604;
cx->state = HTS_DONE;
return ctx;
}
if(cx->state!=HTS_STRT && cx->state!=HTS_IDLE) {
fprintf(stderr, "HTTP: unclean request restart state.\n");
exit(1);
}
cx->keep = keep;
cx->ret = 600;
if(splituri(uri, &cx->host, &cx->path)) {
cx->ret = 601;
cx->state = HTS_DONE;
return ctx;
}
if(http_use_proxy) {
free(cx->path);
cx->path = mystrdup(uri);
}
if(cx->fdhost && strcmp(cx->host, cx->fdhost)) {
free(cx->fdhost);
cx->fdhost = NULL;
PCLOSE(cx->fd);
cx->fd = PERROR;
cx->state = HTS_STRT;
}
if(data) {
if(!dlen)
dlen = strlen(data);
cx->txd = malloc(dlen);
memcpy(cx->txd, data, dlen);
cx->txdl = dlen;
} else
cx->txdl = 0;
cx->contlen = 0;
cx->chunked = 0;
cx->chunkhdr = 0;
cx->rxtogo = 0;
cx->cclose = 0;
cx->tptr = 0;
cx->tlen = 0;
cx->last = time(NULL);
return ctx;
}
void http_async_add_header(void *ctx, char *name, char *data)
{
struct http_ctx *cx = ctx;
cx->thdr = realloc(cx->thdr, cx->thlen + strlen(name) + strlen(data) + 4);
cx->thlen += sprintf(cx->thdr+cx->thlen, "%s: %s\n", name, data);
}
static void process_header(struct http_ctx *cx, char *str)
{
char *p;
if(cx->chunkhdr) {
p = strchr(str, ';');
if(p)
*p = 0;
cx->rxtogo = strtoul(str, NULL, 16);
cx->chunkhdr = 0;
if(!cx->rxtogo)
cx->chunked = 0;
}
if(!str[0]) {
cx->rxtogo = cx->contlen;
cx->chunkhdr = cx->chunked;
if(!cx->contlen && !cx->chunked && cx->ret!=100)
cx->state = HTS_DONE;
return;
}
if(!strncmp(str, "HTTP/", 5)) {
p = strchr(str, ' ');
if(!p) {
cx->ret = 603;
cx->state = HTS_DONE;
return;
}
p++;
cx->ret = atoi(p);
return;
}
if(!strncmp(str, "Content-Length: ", 16)) {
cx->contlen = atoi(str+16);
return;
}
if(!strcmp(str, "Transfer-Encoding: chunked")) {
cx->chunked = 1;
return;
}
if(!strcmp(str, "Connection: close")) {
cx->cclose = 1;
return;
}
}
static void process_byte(struct http_ctx *cx, char ch)
{
if(cx->rxtogo) {
cx->rxtogo--;
if(!cx->rbuf) {
cx->rbuf = malloc(256);
cx->rlen = 256;
}
if(cx->rptr >= cx->rlen-1) {
cx->rlen *= 2;
cx->rbuf = realloc(cx->rbuf, cx->rlen);
}
cx->rbuf[cx->rptr++] = ch;
if(!cx->rxtogo && !cx->chunked)
cx->state = HTS_DONE;
} else {
if(ch == '\n') {
cx->hbuf[cx->hptr] = 0;
process_header(cx, cx->hbuf);
cx->hptr = 0;
} else if(ch != '\r') {
if(cx->hptr >= cx->hlen-1) {
cx->hlen *= 2;
cx->hbuf = realloc(cx->hbuf, cx->hlen);
}
cx->hbuf[cx->hptr++] = ch;
}
}
}
int http_async_req_status(void *ctx)
{
struct http_ctx *cx = ctx;
char *dns,*srv,buf[CHUNK];
int tmp, i;
time_t now = time(NULL);
#ifdef WIN32
unsigned long tmp2;
#endif
switch(cx->state) {
case HTS_STRT:
dns = getserv(cx->host);
srv = getport(cx->host);
if(resolve(dns, srv, &cx->addr)) {
free(dns);
free(srv);
cx->state = HTS_DONE;
cx->ret = 602;
return 1;
}
free(dns);
free(srv);
cx->state = HTS_RSLV;
return 0;
case HTS_RSLV:
cx->state = HTS_CONN;
cx->last = now;
return 0;
case HTS_CONN:
if(cx->fd == PERROR) {
cx->fd = socket(AF_INET, SOCK_STREAM, 0);
if(cx->fd == PERROR)
goto fail;
cx->fdhost = mystrdup(cx->host);
#ifdef WIN32
tmp2 = 1;
if(ioctlsocket(cx->fd, FIONBIO, &tmp2) == SOCKET_ERROR)
goto fail;
#else
tmp = fcntl(cx->fd, F_GETFL);
if(tmp < 0)
goto fail;
if(fcntl(cx->fd, F_SETFL, tmp|O_NONBLOCK) < 0)
goto fail;
#endif
}
if(!connect(cx->fd, (struct sockaddr *)&cx->addr, sizeof(cx->addr)))
cx->state = HTS_IDLE;
#ifdef WIN32
else if(PERRNO==WSAEISCONN)
cx->state = HTS_IDLE;
#endif
#ifdef MACOSX
else if(PERRNO==EISCONN)
cx->state = HTS_IDLE;
#endif
else if(PERRNO!=PEINPROGRESS && PERRNO!=PEALREADY
#ifdef WIN32
&& PERRNO!=PEAGAIN && PERRNO!=WSAEINVAL
#endif
)
goto fail;
if(now-cx->last>http_timeout)
goto timeout;
return 0;
case HTS_IDLE:
if(cx->txdl) {
// generate POST
cx->tbuf = malloc(strlen(cx->host) + strlen(cx->path) + 121 + cx->txdl + cx->thlen);
cx->tptr = 0;
cx->tlen = 0;
cx->tlen += sprintf(cx->tbuf+cx->tlen, "POST %s HTTP/1.1\n", cx->path);
cx->tlen += sprintf(cx->tbuf+cx->tlen, "Host: %s\n", cx->host);
if(!cx->keep)
cx->tlen += sprintf(cx->tbuf+cx->tlen, "Connection: close\n");
if(cx->thdr) {
memcpy(cx->tbuf+cx->tlen, cx->thdr, cx->thlen);
cx->tlen += cx->thlen;
free(cx->thdr);
cx->thdr = NULL;
cx->thlen = 0;
}
cx->tlen += sprintf(cx->tbuf+cx->tlen, "Content-Length: %d\n", cx->txdl);
#ifdef BETA
cx->tlen += sprintf(cx->tbuf+cx->tlen, "X-Powder-Version: %s%dB%d\n", IDENT_VERSION, SAVE_VERSION, MINOR_VERSION);
#else
cx->tlen += sprintf(cx->tbuf+cx->tlen, "X-Powder-Version: %s%dS%d\n", IDENT_VERSION, SAVE_VERSION, MINOR_VERSION);
#endif
cx->tlen += sprintf(cx->tbuf+cx->tlen, "\n");
memcpy(cx->tbuf+cx->tlen, cx->txd, cx->txdl);
cx->tlen += cx->txdl;
free(cx->txd);
cx->txd = NULL;
cx->txdl = 0;
} else {
// generate GET
cx->tbuf = malloc(strlen(cx->host) + strlen(cx->path) + 89 + cx->thlen);
cx->tptr = 0;
cx->tlen = 0;
cx->tlen += sprintf(cx->tbuf+cx->tlen, "GET %s HTTP/1.1\n", cx->path);
cx->tlen += sprintf(cx->tbuf+cx->tlen, "Host: %s\n", cx->host);
if(cx->thdr) {
memcpy(cx->tbuf+cx->tlen, cx->thdr, cx->thlen);
cx->tlen += cx->thlen;
free(cx->thdr);
cx->thdr = NULL;
cx->thlen = 0;
}
if(!cx->keep)
cx->tlen += sprintf(cx->tbuf+cx->tlen, "Connection: close\n");
#ifdef BETA
cx->tlen += sprintf(cx->tbuf+cx->tlen, "X-Powder-Version: %s%dB%d\n", IDENT_VERSION, SAVE_VERSION, MINOR_VERSION);
#else
cx->tlen += sprintf(cx->tbuf+cx->tlen, "X-Powder-Version: %s%dS%d\n", IDENT_VERSION, SAVE_VERSION, MINOR_VERSION);
#endif
cx->tlen += sprintf(cx->tbuf+cx->tlen, "\n");
}
cx->state = HTS_XMIT;
cx->last = now;
return 0;
case HTS_XMIT:
tmp = send(cx->fd, cx->tbuf+cx->tptr, cx->tlen-cx->tptr, 0);
if(tmp==PERROR && PERRNO!=PEAGAIN && PERRNO!=PEINTR)
goto fail;
if(tmp!=PERROR) {
cx->tptr += tmp;
if(cx->tptr == cx->tlen) {
cx->tptr = 0;
cx->tlen = 0;
if(cx->tbuf)
free(cx->tbuf);
cx->state = HTS_RECV;
}
cx->last = now;
}
if(now-cx->last>http_timeout)
goto timeout;
return 0;
case HTS_RECV:
tmp = recv(cx->fd, buf, CHUNK, 0);
if(tmp==PERROR && PERRNO!=PEAGAIN && PERRNO!=PEINTR)
goto fail;
if(tmp!=PERROR) {
for(i=0;i<tmp;i++) {
process_byte(cx, buf[i]);
if(cx->state == HTS_DONE)
return 1;
}
cx->last = now;
}
if(now-cx->last>http_timeout)
goto timeout;
return 0;
case HTS_DONE:
return 1;
}
return 0;
fail:
cx->ret = 600;
cx->state = HTS_DONE;
return 1;
timeout:
cx->ret = 605;
cx->state = HTS_DONE;
return 1;
}
char *http_async_req_stop(void *ctx, int *ret, int *len)
{
struct http_ctx *cx = ctx;
char *rxd;
if(cx->state != HTS_DONE)
while(!http_async_req_status(ctx)) ;
if(cx->host) {
free(cx->host);
cx->host = NULL;
}
if(cx->path) {
free(cx->path);
cx->path = NULL;
}
if(cx->txd) {
free(cx->txd);
cx->txd = NULL;
cx->txdl = 0;
}
if(cx->hbuf) {
free(cx->hbuf);
cx->hbuf = NULL;
}
if(cx->thdr) {
free(cx->thdr);
cx->thdr = NULL;
cx->thlen = 0;
}
if(ret)
*ret = cx->ret;
if(len)
*len = cx->rptr;
if(cx->rbuf)
cx->rbuf[cx->rptr] = 0;
rxd = cx->rbuf;
cx->rbuf = NULL;
cx->rlen = 0;
cx->rptr = 0;
cx->contlen = 0;
if(!cx->keep)
http_async_req_close(ctx);
else if(cx->cclose) {
PCLOSE(cx->fd);
cx->fd = PERROR;
if(cx->fdhost) {
free(cx->fdhost);
cx->fdhost = NULL;
}
cx->state = HTS_STRT;
} else
cx->state = HTS_IDLE;
return rxd;
}
void http_async_get_length(void *ctx, int *total, int *done)
{
struct http_ctx *cx = ctx;
if(done)
*done = cx->rptr;
if(total)
*total = cx->contlen;
}
void http_async_req_close(void *ctx)
{
struct http_ctx *cx = ctx;
void *tmp;
if(cx->host) {
cx->keep = 1;
tmp = http_async_req_stop(ctx, NULL, NULL);
if(tmp)
free(tmp);
}
if(cx->fdhost)
free(cx->fdhost);
PCLOSE(cx->fd);
free(ctx);
}
char *http_simple_get(char *uri, int *ret, int *len)
{
void *ctx = http_async_req_start(NULL, uri, NULL, 0, 0);
if(!ctx) {
if(ret)
*ret = 600;
if(len)
*len = 0;
return NULL;
}
return http_async_req_stop(ctx, ret, len);
}
static char hex[] = "0123456789abcdef";
void http_auth_headers(void *ctx, char *user, char *pass)
{
char *tmp;
int i;
unsigned char hash[16];
unsigned int m;
struct md5_context md5;
if(user) {
http_async_add_header(ctx, "X-Auth-User", user);
if(pass) {
md5_init(&md5);
md5_update(&md5, (unsigned char *)user, strlen(user));
md5_update(&md5, (unsigned char *)"-", 1);
m = 0;
md5_update(&md5, (unsigned char *)pass, strlen(pass));
md5_final(hash, &md5);
tmp = malloc(33);
for(i=0;i<16;i++) {
tmp[i*2] = hex[hash[i]>>4];
tmp[i*2+1] = hex[hash[i]&15];
}
tmp[32] = 0;
http_async_add_header(ctx, "X-Auth-Hash", tmp);
free(tmp);
}
}
}
char *http_auth_get(char *uri, char *user, char *pass, int *ret, int *len)
{
void *ctx = http_async_req_start(NULL, uri, NULL, 0, 0);
if(!ctx) {
if(ret)
*ret = 600;
if(len)
*len = 0;
return NULL;
}
return http_async_req_stop(ctx, ret, len);
}
char *http_simple_post(char *uri, char *data, int dlen, int *ret, int *len)
{
void *ctx = http_async_req_start(NULL, uri, data, dlen, 0);
if(!ctx) {
if(ret)
*ret = 600;
if(len)
*len = 0;
return NULL;
}
return http_async_req_stop(ctx, ret, len);
}
char *http_ret_text(int ret)
{
switch(ret) {
case 100: return "Continue";
case 101: return "Switching Protocols";
case 102: return "Processing";
case 200: return "OK";
case 201: return "Created";
case 202: return "Accepted";
case 203: return "Non-Authoritative Information";
case 204: return "No Content";
case 205: return "Reset Content";
case 206: return "Partial Content";
case 207: return "Multi-Status";
case 300: return "Multiple Choices";
case 301: return "Moved Permanently";
case 302: return "Found";
case 303: return "See Other";
case 304: return "Not Modified";
case 305: return "Use Proxy";
case 306: return "Switch Proxy";
case 307: return "Temporary Redirect";
case 400: return "Bad Request";
case 401: return "Unauthorized";
case 402: return "Payment Required";
case 403: return "Forbidden";
case 404: return "Not Found";
case 405: return "Method Not Allowed";
case 406: return "Not Acceptable";
case 407: return "Proxy Authentication Required";
case 408: return "Request Timeout";
case 409: return "Conflict";
case 410: return "Gone";
case 411: return "Length Required";
case 412: return "Precondition Failed";
case 413: return "Request Entity Too Large";
case 414: return "Request URI Too Long";
case 415: return "Unsupported Media Type";
case 416: return "Requested Range Not Satisfiable";
case 417: return "Expectation Failed";
case 422: return "Unprocessable Entity";
case 423: return "Locked";
case 424: return "Failed Dependency";
case 425: return "Unordered Collection";
case 426: return "Upgrade Required";
case 500: return "Internal Server Error";
case 501: return "Not Implemented";
case 502: return "Bad Gateway";
case 503: return "Service Unavailable";
case 504: return "Gateway Timeout";
case 505: return "HTTP Version Not Supported";
case 506: return "Variant Also Negotiates";
case 507: return "Insufficient Storage";
case 509: return "Bandwidth Limit Exceeded";
case 510: return "Not Extended";
case 600: return "Internal Client Error";
case 601: return "Unsupported Protocol";
case 602: return "Server Not Found";
case 603: return "Malformed Response";
case 604: return "Network Not Available";
case 605: return "Request Timed Out";
default: return "Unknown Status Code";
}
}
char *http_multipart_post(char *uri, char **names, char **parts, int *plens, char *user, char *pass, int *ret, int *len)
{
void *ctx;
char *data = NULL, *tmp, *p;
int dlen = 0, i, j;
unsigned char hash[16];
unsigned char boundary[32], ch;
int blen = 0;
unsigned int map[62], m;
struct md5_context md5;
//struct md5_context md52;
int own_plen = 0;
if(names) {
if(!plens) {
own_plen = 1;
for(i=0;names[i];i++) ;
plens = calloc(i, sizeof(int));
for(i=0;names[i];i++)
plens[i] = strlen(parts[i]);
}
retry:
if(blen >= 31)
goto fail;
memset(map, 0, 62*sizeof(int));
for(i=0;names[i];i++) {
for(j=0;j<plens[i]-blen;j++)
if(!blen || !memcmp(parts[i]+j, boundary, blen)) {
ch = parts[i][j+blen];
if(ch>='0' && ch<='9')
map[ch-'0']++;
else if(ch>='A' && ch<='Z')
map[ch-'A'+10]++;
else if(ch>='a' && ch<='z')
map[ch-'a'+36]++;
}
}
m = ~0;
j = 61;
for(i=0;i<62;i++)
if(map[i]<m) {
m = map[i];
j = i;
}
if(j<10)
boundary[blen] = '0'+j;
else if(j<36)
boundary[blen] = 'A'+(j-10);
else
boundary[blen] = 'a'+(j-36);
blen++;
if(map[j])
goto retry;
boundary[blen] = 0;
for(i=0;names[i];i++)
dlen += blen+strlen(names[i])+plens[i]+128;
dlen += blen+8;
data = malloc(dlen);
dlen = 0;
for(i=0;names[i];i++) {
dlen += sprintf(data+dlen, "--%s\r\n", boundary);
dlen += sprintf(data+dlen, "Content-transfer-encoding: binary\r\n");
if(strchr(names[i], ':')) {
tmp = mystrdup(names[i]);
p = strchr(tmp, ':');
*p = 0;
dlen += sprintf(data+dlen, "content-disposition: form-data; name=\"%s\"; ", tmp);
free(tmp);
p = strchr(names[i], ':');
dlen += sprintf(data+dlen, "filename=\"%s\"\r\n\r\n", p+1);
} else
dlen += sprintf(data+dlen, "content-disposition: form-data; name=\"%s\"\r\n\r\n", names[i]);
memcpy(data+dlen, parts[i], plens[i]);
dlen += plens[i];
dlen += sprintf(data+dlen, "\r\n");
}
dlen += sprintf(data+dlen, "--%s--\r\n", boundary);
}
ctx = http_async_req_start(NULL, uri, data, dlen, 0);
if(!ctx)
goto fail;
if(user) {
http_async_add_header(ctx, "X-Auth-User", user);
if(pass) {
md5_init(&md5);
md5_update(&md5, (unsigned char *)user, strlen(user));
md5_update(&md5, (unsigned char *)"-", 1);
m = 0;
if(names) {
for(i=0;names[i];i++) {
//md5_update(&md5, (unsigned char *)parts[i], plens[i]); //WHY?
//md5_update(&md5, (unsigned char *)"-", 1);
p = strchr(names[i], ':');
if(p)
m += (p - names[i]) + 1;
else
m += strlen(names[i])+1;
}
tmp = malloc(m);
m = 0;
for(i=0;names[i];i++) {
p = strchr(names[i], ':');
if(m) {
tmp[m] = ' ';
m ++;
}
if(p) {
memcpy(tmp+m, names[i], p-names[i]);
m += p - names[i];
} else {
strcpy(tmp+m, names[i]);
m += strlen(names[i]);
}
}
tmp[m] = 0;
http_async_add_header(ctx, "X-Auth-Objects", tmp);
free(tmp);
}
md5_update(&md5, (unsigned char *)pass, strlen(pass));
md5_final(hash, &md5);
tmp = malloc(33);
for(i=0;i<16;i++) {
tmp[i*2] = hex[hash[i]>>4];
tmp[i*2+1] = hex[hash[i]&15];
}
tmp[32] = 0;
http_async_add_header(ctx, "X-Auth-Hash", tmp);
free(tmp);
}
}
if(data) {
tmp = malloc(32+strlen((char *)boundary));
sprintf(tmp, "multipart/form-data, boundary=%s", boundary);
http_async_add_header(ctx, "Content-type", tmp);
free(tmp);
free(data);
}
if(own_plen)
free(plens);
return http_async_req_stop(ctx, ret, len);
fail:
if(data)
free(data);
if(own_plen)
free(plens);
if(ret)
*ret = 600;
if(len)
*len = 0;
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink