trunk/Src/wptHTTP.c

/* wptHTTP.c - Generic HTTP support
 *      Copyright (C) 2004, 2005 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT 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.
 *  
 * WinPT 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 WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <ctype.h>
#include <errno.h>

#include "wptHTTP.h"
#include "wptTypes.h"
#include "wptErrors.h"


static int parse_headers (int fd, http_head_t *r_head);


static int
http_head_new (http_head_t * head, const char * val)
{
    http_head_t h;
    
    h = calloc (1, sizeof *h + strlen (val) + 1);
    if (!h)
        BUG (0);
    strcpy (h->d, val);
    *head = h;
    return 0;
}


static void
http_head_free (http_head_t head)
{
    http_head_t h;
    
    while (head) {
        h = head->next;
        free (head);
        head = h;
    }
}


static void
http_head_add (http_head_t root, http_head_t node)
{
    http_head_t n;
    
    for (n = root; n->next; n=n->next)
        ;
    n->next = node;
}


static http_head_t
http_head_find (http_head_t root, const char * name,
                const char ** val)
{
    http_head_t n;
    
    for (n = root; n; n = n->next) {
        if (strlen (n->d) >= strlen (name) &&
            !strncmp (n->d, name, strlen (name))) {
            *val = n->d + strlen (name);
            return n;
        }
    }
    return NULL;
}


static int
http_connect (const char * host, int port, int * r_fd)
{
    struct hostent * hp;
    struct sockaddr_in srv;
    unsigned long addr = 0;
    int i = 1;
    int fd;
    
    *r_fd = 0;
    memset (&srv, 0, sizeof srv);
    srv.sin_port = htons ((unsigned short)port);
    srv.sin_family = AF_INET;
    
    if (isalpha (*host)) {
        hp = gethostbyname (host);
        if (hp == NULL)
            return WPTERR_WINSOCK_CONNECT;
        memcpy (&srv.sin_addr, hp->h_addr, hp->h_length);
    }
    else {
        addr = inet_addr (host);
        if (addr == -1)
            return WPTERR_WINSOCK_CONNECT;
        memcpy (&srv.sin_addr, &addr, sizeof addr);
    }
            
    fd = socket (AF_INET, SOCK_STREAM, 0);
    if (fd < 0)
        return WPTERR_WINSOCK_SOCKET;

    if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&i, sizeof i)) {
        closesocket (fd);
        return WPTERR_WINSOCK_SOCKET;
    }
    
    if (connect (fd, (struct sockaddr *)&srv, sizeof srv)) {
        closesocket (fd);
        return WPTERR_WINSOCK_CONNECT;
    }
    
    *r_fd = fd;
    return 0;
}


static int
http_close (int fd)
{
    closesocket (fd);
    return 0;
}


static int
http_data_avail (int fd)
{
    struct timeval tv;
    fd_set inp;
    int n;

    FD_ZERO (&inp);
    FD_SET (fd, &inp);
    tv.tv_sec = 1;
    tv.tv_usec = 0;

    n = select (fd+1, &inp, NULL, NULL, &tv);
    if (n && FD_ISSET (fd, &inp))
        return n;
    return 0;
}


static int
http_read_line (int fd, char * buf, size_t nbuf,
                int nonblock, int * nn, int * eof)
{
    char c;
    int n, i;
    
    if (nn)
        *nn = 0;
    if (eof)
        *eof = 0;
    i = 0;
    do {
        if (nonblock == 1 && http_data_avail (fd) == 0) {
            buf[i++] = '\0';
            i = -1;
            break;
        }
        n = recv (fd, &c, 1, 0);
        if (n == -1)
            break;
        if (n == 0 || nbuf == 0 || c == '\n') {
            if (n == 0) {
                if (eof)
                    *eof = 1;
                buf[i++] = '\0';
            }
            else {
                buf[i++] = c;
                buf[i] = '\0';
            }
            break;
        }
        else {
            buf[i++] = c;
            nbuf--;
        }
    } while (n > 0 && i != -1);
    
    if (nn)
        *nn = i;
    return 0;
}


static int
http_send_req (int fd, const char * host, const char * url)
{
    char * p;
    int n;
    
    if (*url == '/')
        url++;
    if (url == NULL)
        url = "";
    p = malloc (strlen (url) + strlen (host) + 64);
    if (p == NULL)
        BUG (0);
    sprintf (p, "GET /%s HTTP/1.1\r\n"
                "Host: %s\r\n"
                "\r\n"
                "\r\n",
             url, host);
    n = send (fd, p, strlen (p), 0);
    free (p);
    if (n == -1)
        return SOCKET_ERROR;
    return 0;
}


int
http_send_request2 (const char * url, http_hd_t * r_hd)
{
    http_hd_t hd;
    char * host = NULL, * p;
    char tmpbuf[512];
    int rc;

    memset (tmpbuf, 0, 512);
    strncpy (tmpbuf, url, 512);
    
    if (strlen (url) < 10 || strncmp (url, "http://", 7))
        return WPTERR_GENERAL;
    url += 7;
    p = strtok (tmpbuf+7, "/");
    if (p == NULL)
        return WPTERR_GENERAL;
    host = strdup (p);
    if (host == NULL)
        BUG (0);
    p = strchr (url, '/');
    if (p == NULL) {
        free (host);
        return WPTERR_GENERAL;
    }
    rc = http_send_request (host, 80, p+1, &hd);
    *r_hd = hd;
    free (host);
    return rc;
}


int
http_send_request (const char * host, int port, const char * url,
                   http_hd_t * r_hd)
{
    http_hd_t hd;
    int rc;

    http_hd_new (&hd);
    rc = http_connect (host, port, &hd->fd);
    if (!rc)
        rc = http_send_req (hd->fd, host, url);
    if (r_hd)
        *r_hd = hd;
    else
        http_hd_free (hd);
    return rc;
}


int
http_req_new (http_req_t * ctx)
{
    http_req_t c;
    c = calloc (1, sizeof * c);
    if (c == NULL)
        BUG (0);
    *ctx = c;
    return 0;
}


void
http_req_free (http_req_t ctx)
{
    if (!ctx)
        return;
    http_head_free (ctx->head);
    if (ctx->url)
        free (ctx->url);
    free (ctx);
}


static int
parse_statline (const char * buf, int * code)
{
    int tmp = 0;
    
    if (strlen (buf) < 8 ||
        (strncmp (buf, "HTTP/1.", 7)))
        return WPTERR_GENERAL;
    buf += 8; /* skip HTTP/1.x */
    buf++;    /* white space */
    tmp = atoi (buf);
    if (tmp == 0)
        return WPTERR_GENERAL;
    *code = tmp;
    buf += 3;
    buf++; /* whitespace */
    return 0;
}


static int
parse_headers (int fd, http_head_t * r_head)
{
    http_head_t h, head = NULL;
    char buf[300];
    int nn;
    int rc;
    
    do  {
        rc = http_read_line (fd, buf, 299, 1, &nn, NULL);
        if (rc)
            return rc;
        if (nn == 2)
            break; /* reach empty line */
        http_head_new (&h, buf);
        if (head == NULL)
            head = h;
        else
            http_head_add (head, h);
    } while (rc == 0);
    if (r_head)
        *r_head = head;
    else
        http_head_free (head);
    return 0;
}


static int
read_binary (int fd, int nlen, FILE * out)
{
    char buf[1024+1];
    int n;

    do
    {
        n = recv (fd, buf, nlen > 1024? 1024 : nlen, 0);
        if (n == -1)
            return SOCKET_ERROR;
        if (n == 0)
            break;
        nlen -= n;
        fwrite (buf, 1, n, out);
    } while (nlen > 0);
    return 0;
}


static int
parse_data (int fd, http_head_t head, FILE * out)
{
    http_head_t h;
    const char * s = "Content-Length: ", * val;
    char buf[1024+1];
    int nlen = 0, nn = 0, n, eof=0;
    int rc;
    
    h = http_head_find (head, s, &val);
    if (h)
        nlen = atoi (val);
    else {
        h = http_head_find (head, "Connection: ", &val);
        if (h == NULL || strncmp (val, "close", 4))
            return WPTERR_GENERAL;
    }

    h = http_head_find (head, "Content-Type: ", &val);
    if (h == NULL)
        return WPTERR_GENERAL;
    if (strncmp (val, "text", 4))
        return read_binary (fd, nlen, out);
    
    do {
        rc = http_read_line (fd, buf, 1024, 1, &n, &eof);
        if (rc)
            return rc;
        if (n > 0)
            fwrite (buf, 1, n, out);
        if (nlen > 0) {
            nn += n;
            if (nlen == nn)
                break;
        }
    } while (eof == 0);
    return 0;
}


static int
check_status (int code, int * statcode)
{
    if (code != HTTP_STAT_200) {
        if (statcode)
            *statcode = code;
        if (code == HTTP_STAT_400 ||
            code == HTTP_STAT_403 ||
            code == HTTP_STAT_404 ||
            code == HTTP_STAT_405)
            return WPTERR_GENERAL;
    }
    return 0;
}


int
http_parse_response (http_hd_t hd, int * statcode)
{
    char buf[300];
    int rc;
    int code = 0, nn = 0;

    if (statcode)
        *statcode = 0;
    rc = http_read_line (hd->fd, buf, 299, 1, &nn, NULL);
    if (rc)
        return rc;
    rc = parse_statline (buf, &code);
    if (rc)
        return rc;
    rc = check_status (code, statcode);
    if (rc)
        return rc;
    rc = parse_headers (hd->fd, &hd->head);
    if (rc)
        return rc;
    return 0;
}


int
http_parse_data (http_hd_t hd, FILE * out)
{
    int rc = 0;
    rc = parse_data (hd->fd, hd->head, out);
    http_close (hd->fd);    
    return rc;
}


int
http_hd_new (http_hd_t * r_hd)
{
    http_hd_t hd;

    if (!r_hd)
        return -1;
    hd = calloc (1, sizeof * hd);
    if (hd == NULL)
        abort ();
    *r_hd = hd;
    return 0;
}


void
http_hd_free (http_hd_t hd)
{
    if (!hd)
        return;
    http_head_free (hd->head);
    http_close (hd->fd);
    free (hd);
}
1	werner	36	/* wptHTTP.c - Generic HTTP support
2			* Copyright (C) 2004, 2005 Timo Schulz
3			*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU General Public License
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20			#ifdef HAVE_CONFIG_H
21			#include <config.h>
22			#endif
23
24			#include <stdio.h>
25			#include <stdio.h>
26			#include <stdlib.h>
27			#include <string.h>
28			#include <windows.h>
29			#include <ctype.h>
30			#include <errno.h>
31
32			#include "wptHTTP.h"
33			#include "wptTypes.h"
34			#include "wptErrors.h"
35
36
37			static int parse_headers (int fd, http_head_t *r_head);
38
39
40			static int
41			http_head_new (http_head_t * head, const char * val)
42			{
43			http_head_t h;
44
45			h = calloc (1, sizeof *h + strlen (val) + 1);
46			if (!h)
47			BUG (0);
48			strcpy (h->d, val);
49			*head = h;
50			return 0;
51			}
52
53
54			static void
55			http_head_free (http_head_t head)
56			{
57			http_head_t h;
58
59			while (head) {
60			h = head->next;
61			free (head);
62			head = h;
63			}
64			}
65
66
67			static void
68			http_head_add (http_head_t root, http_head_t node)
69			{
70			http_head_t n;
71
72			for (n = root; n->next; n=n->next)
73			;
74			n->next = node;
75			}
76
77
78			static http_head_t
79			http_head_find (http_head_t root, const char * name,
80			const char ** val)
81			{
82			http_head_t n;
83
84			for (n = root; n; n = n->next) {
85			if (strlen (n->d) >= strlen (name) &&
86			!strncmp (n->d, name, strlen (name))) {
87			*val = n->d + strlen (name);
88			return n;
89			}
90			}
91			return NULL;
92			}
93
94
95			static int
96			http_connect (const char * host, int port, int * r_fd)
97			{
98			struct hostent * hp;
99			struct sockaddr_in srv;
100			unsigned long addr = 0;
101			int i = 1;
102			int fd;
103
104			*r_fd = 0;
105			memset (&srv, 0, sizeof srv);
106			srv.sin_port = htons ((unsigned short)port);
107			srv.sin_family = AF_INET;
108
109			if (isalpha (*host)) {
110			hp = gethostbyname (host);
111			if (hp == NULL)
112			return WPTERR_WINSOCK_CONNECT;
113			memcpy (&srv.sin_addr, hp->h_addr, hp->h_length);
114			}
115			else {
116			addr = inet_addr (host);
117			if (addr == -1)
118			return WPTERR_WINSOCK_CONNECT;
119			memcpy (&srv.sin_addr, &addr, sizeof addr);
120			}
121
122			fd = socket (AF_INET, SOCK_STREAM, 0);
123			if (fd < 0)
124			return WPTERR_WINSOCK_SOCKET;
125
126			if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&i, sizeof i)) {
127			closesocket (fd);
128			return WPTERR_WINSOCK_SOCKET;
129			}
130
131			if (connect (fd, (struct sockaddr *)&srv, sizeof srv)) {
132			closesocket (fd);
133			return WPTERR_WINSOCK_CONNECT;
134			}
135
136			*r_fd = fd;
137			return 0;
138			}
139
140
141			static int
142			http_close (int fd)
143			{
144			closesocket (fd);
145			return 0;
146			}
147
148
149			static int
150			http_data_avail (int fd)
151			{
152			struct timeval tv;
153			fd_set inp;
154			int n;
155
156			FD_ZERO (&inp);
157			FD_SET (fd, &inp);
158			tv.tv_sec = 1;
159			tv.tv_usec = 0;
160
161			n = select (fd+1, &inp, NULL, NULL, &tv);
162			if (n && FD_ISSET (fd, &inp))
163			return n;
164			return 0;
165			}
166
167
168			static int
169			http_read_line (int fd, char * buf, size_t nbuf,
170			int nonblock, int * nn, int * eof)
171			{
172			char c;
173			int n, i;
174
175			if (nn)
176			*nn = 0;
177			if (eof)
178			*eof = 0;
179			i = 0;
180			do {
181			if (nonblock == 1 && http_data_avail (fd) == 0) {
182			buf[i++] = '\0';
183			i = -1;
184			break;
185			}
186			n = recv (fd, &c, 1, 0);
187			if (n == -1)
188			break;
189			if (n == 0 \|\| nbuf == 0 \|\| c == '\n') {
190			if (n == 0) {
191			if (eof)
192			*eof = 1;
193			buf[i++] = '\0';
194			}
195			else {
196			buf[i++] = c;
197			buf[i] = '\0';
198			}
199			break;
200			}
201			else {
202			buf[i++] = c;
203			nbuf--;
204			}
205			} while (n > 0 && i != -1);
206
207			if (nn)
208			*nn = i;
209			return 0;
210			}
211
212
213			static int
214			http_send_req (int fd, const char * host, const char * url)
215			{
216			char * p;
217			int n;
218
219			if (*url == '/')
220			url++;
221			if (url == NULL)
222			url = "";
223			p = malloc (strlen (url) + strlen (host) + 64);
224			if (p == NULL)
225			BUG (0);
226			sprintf (p, "GET /%s HTTP/1.1\r\n"
227			"Host: %s\r\n"
228			"\r\n"
229			"\r\n",
230			url, host);
231			n = send (fd, p, strlen (p), 0);
232			free (p);
233			if (n == -1)
234			return SOCKET_ERROR;
235			return 0;
236			}
237
238
239			int
240			http_send_request2 (const char * url, http_hd_t * r_hd)
241			{
242			http_hd_t hd;
243			char * host = NULL, * p;
244			char tmpbuf[512];
245			int rc;
246
247			memset (tmpbuf, 0, 512);
248			strncpy (tmpbuf, url, 512);
249
250			if (strlen (url) < 10 \|\| strncmp (url, "http://", 7))
251			return WPTERR_GENERAL;
252			url += 7;
253			p = strtok (tmpbuf+7, "/");
254			if (p == NULL)
255			return WPTERR_GENERAL;
256			host = strdup (p);
257			if (host == NULL)
258			BUG (0);
259			p = strchr (url, '/');
260			if (p == NULL) {
261			free (host);
262			return WPTERR_GENERAL;
263			}
264			rc = http_send_request (host, 80, p+1, &hd);
265			*r_hd = hd;
266			free (host);
267			return rc;
268			}
269
270
271			int
272			http_send_request (const char * host, int port, const char * url,
273			http_hd_t * r_hd)
274			{
275			http_hd_t hd;
276			int rc;
277
278			http_hd_new (&hd);
279			rc = http_connect (host, port, &hd->fd);
280			if (!rc)
281			rc = http_send_req (hd->fd, host, url);
282			if (r_hd)
283			*r_hd = hd;
284			else
285			http_hd_free (hd);
286			return rc;
287			}
288
289
290			int
291			http_req_new (http_req_t * ctx)
292			{
293			http_req_t c;
294			c = calloc (1, sizeof * c);
295			if (c == NULL)
296			BUG (0);
297			*ctx = c;
298			return 0;
299			}
300
301
302			void
303			http_req_free (http_req_t ctx)
304			{
305			if (!ctx)
306			return;
307			http_head_free (ctx->head);
308			if (ctx->url)
309			free (ctx->url);
310			free (ctx);
311			}
312
313
314			static int
315			parse_statline (const char * buf, int * code)
316			{
317			int tmp = 0;
318
319			if (strlen (buf) < 8 \|\|
320			(strncmp (buf, "HTTP/1.", 7)))
321			return WPTERR_GENERAL;
322			buf += 8; /* skip HTTP/1.x */
323			buf++; /* white space */
324			tmp = atoi (buf);
325			if (tmp == 0)
326			return WPTERR_GENERAL;
327			*code = tmp;
328			buf += 3;
329			buf++; /* whitespace */
330			return 0;
331			}
332
333
334			static int
335			parse_headers (int fd, http_head_t * r_head)
336			{
337			http_head_t h, head = NULL;
338			char buf[300];
339			int nn;
340			int rc;
341
342			do {
343			rc = http_read_line (fd, buf, 299, 1, &nn, NULL);
344			if (rc)
345			return rc;
346			if (nn == 2)
347			break; /* reach empty line */
348			http_head_new (&h, buf);
349			if (head == NULL)
350			head = h;
351			else
352			http_head_add (head, h);
353			} while (rc == 0);
354			if (r_head)
355			*r_head = head;
356			else
357			http_head_free (head);
358			return 0;
359			}
360
361
362			static int
363			read_binary (int fd, int nlen, FILE * out)
364			{
365			char buf[1024+1];
366			int n;
367
368			do
369			{
370			n = recv (fd, buf, nlen > 1024? 1024 : nlen, 0);
371			if (n == -1)
372			return SOCKET_ERROR;
373			if (n == 0)
374			break;
375			nlen -= n;
376			fwrite (buf, 1, n, out);
377			} while (nlen > 0);
378			return 0;
379			}
380
381
382			static int
383			parse_data (int fd, http_head_t head, FILE * out)
384			{
385			http_head_t h;
386			const char * s = "Content-Length: ", * val;
387			char buf[1024+1];
388			int nlen = 0, nn = 0, n, eof=0;
389			int rc;
390
391			h = http_head_find (head, s, &val);
392			if (h)
393			nlen = atoi (val);
394			else {
395			h = http_head_find (head, "Connection: ", &val);
396			if (h == NULL \|\| strncmp (val, "close", 4))
397			return WPTERR_GENERAL;
398			}
399
400			h = http_head_find (head, "Content-Type: ", &val);
401			if (h == NULL)
402			return WPTERR_GENERAL;
403			if (strncmp (val, "text", 4))
404			return read_binary (fd, nlen, out);
405
406			do {
407			rc = http_read_line (fd, buf, 1024, 1, &n, &eof);
408			if (rc)
409			return rc;
410			if (n > 0)
411			fwrite (buf, 1, n, out);
412			if (nlen > 0) {
413			nn += n;
414			if (nlen == nn)
415			break;
416			}
417			} while (eof == 0);
418			return 0;
419			}
420
421
422			static int
423			check_status (int code, int * statcode)
424			{
425			if (code != HTTP_STAT_200) {
426			if (statcode)
427			*statcode = code;
428			if (code == HTTP_STAT_400 \|\|
429			code == HTTP_STAT_403 \|\|
430			code == HTTP_STAT_404 \|\|
431			code == HTTP_STAT_405)
432			return WPTERR_GENERAL;
433			}
434			return 0;
435			}
436
437
438			int
439			http_parse_response (http_hd_t hd, int * statcode)
440			{
441			char buf[300];
442			int rc;
443			int code = 0, nn = 0;
444
445			if (statcode)
446			*statcode = 0;
447			rc = http_read_line (hd->fd, buf, 299, 1, &nn, NULL);
448			if (rc)
449			return rc;
450			rc = parse_statline (buf, &code);
451			if (rc)
452			return rc;
453			rc = check_status (code, statcode);
454			if (rc)
455			return rc;
456			rc = parse_headers (hd->fd, &hd->head);
457			if (rc)
458			return rc;
459			return 0;
460			}
461
462
463			int
464			http_parse_data (http_hd_t hd, FILE * out)
465			{
466			int rc = 0;
467			rc = parse_data (hd->fd, hd->head, out);
468			http_close (hd->fd);
469			return rc;
470			}
471
472
473			int
474			http_hd_new (http_hd_t * r_hd)
475			{
476			http_hd_t hd;
477
478			if (!r_hd)
479			return -1;
480			hd = calloc (1, sizeof * hd);
481			if (hd == NULL)
482			abort ();
483			*r_hd = hd;
484			return 0;
485			}
486
487
488			void
489			http_hd_free (http_hd_t hd)
490			{
491			if (!hd)
492			return;
493			http_head_free (hd->head);
494			http_close (hd->fd);
495			free (hd);
496			}