aboutsummaryrefslogtreecommitdiffstats
path: root/lib/ini.c
blob: aa291bb272ce8f02cb64cc4cc51ed5b0a675c47c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
  /********************************************************************\
  * BitlBee -- An IRC to other IM-networks gateway                     *
  *                                                                    *
  * Copyright 2002-2008 Wilmer van der Gaast and others                *
  \********************************************************************/

/* INI file reading code						*/

/*
  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 with
  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
  Suite 330, Boston, MA  02111-1307  USA
*/
#define BITLBEE_CORE
#include "bitlbee.h"

ini_t *ini_open( char *file )
{
	int fd;
	ini_t *ini = NULL;
	struct stat fi;
	
	if( ( fd = open( file, O_RDONLY ) ) != -1 &&
	    fstat( fd, &fi ) == 0 &&
	    fi.st_size <= 16384 &&
	    ( ini = g_malloc( sizeof( ini_t ) + fi.st_size + 1 ) ) &&
	    read( fd, ini->file, fi.st_size ) == fi.st_size )
	{
		memset( ini, 0, sizeof( ini_t ) );
		ini->size = fi.st_size;
		ini->file[ini->size] = 0;
		ini->cur = ini->file;
		ini->c_section = "";
		
		close( fd );
		
		return ini;
	}

	if( fd >= 0 )
		close( fd );
	
	ini_close( ini );

	return NULL;
}

/* Strips leading and trailing whitespace and returns a pointer to the first
   non-ws character of the given string. */
static char *ini_strip_whitespace( char *in )
{
	char *e;

	while( isspace( *in ) )
		in++;

	e = in + strlen( in ) - 1;
	while( e > in && isspace( *e ) )
		e--;
	e[1] = 0;
	
	return in;
}

int ini_read( ini_t *file )
{
	char *s;
	
	while( file->cur && file->cur < file->file + file->size )
	{
		char *e, *next;
		
		file->line++;

		/* Find the end of line */
		if( ( e = strchr( file->cur, '\n' ) ) != NULL )
		{
			*e = 0;
			next = e + 1;
		}
		else
		{
			/* No more lines. */
			e = file->cur + strlen( file->cur );
			next = NULL;
		}
		
		/* Comment? */
		if( ( s = strchr( file->cur, '#' ) ) != NULL )
			*s = 0;
		
		file->cur = ini_strip_whitespace( file->cur );
		
		if( *file->cur == '[' )
		{
			file->cur++;
			if( ( s = strchr( file->cur, ']' ) ) != NULL )
			{
				*s = 0;
				file->c_section = file->cur;
			}
		}
		else if( ( s = strchr( file->cur, '=' ) ) != NULL )
		{
			*s = 0;
			file->key = ini_strip_whitespace( file->cur );
			file->value = ini_strip_whitespace( s + 1 );
			
			if( ( s = strchr( file->key, '.' ) ) != NULL )
			{
				*s = 0;
				file->section = file->key;
				file->key = s + 1;
			}
			else
			{
				file->section = file->c_section;
			}
			
			file->cur = next;
			return 1;
		}
		/* else: noise/comment/etc, let's just ignore it. */

		file->cur = next;
	}
	
	return 0;
}

void ini_close( ini_t *file )
{
	g_free( file );
}
p">); return NULL; } request = g_strdup_printf( "GET %s HTTP/1.0\r\n" "Host: %s\r\n" "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n" "\r\n", url->file, url->host ); ret = http_dorequest( url->host, url->port, url->proto == PROTO_HTTPS, request, func, data ); g_free( url ); g_free( request ); return ret; } /* This one is actually pretty simple... Might get more calls if we can't write the whole request at once. */ static gboolean http_connected( gpointer data, int source, b_input_condition cond ) { struct http_request *req = data; int st; if( source < 0 ) goto error; if( req->inpa > 0 ) b_event_remove( req->inpa ); sock_make_nonblocking( req->fd ); if( req->ssl ) { st = ssl_write( req->ssl, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( ssl_errno != SSL_AGAIN ) { ssl_disconnect( req->ssl ); goto error; } } } else { st = write( source, req->request + req->bytes_written, req->request_length - req->bytes_written ); if( st < 0 ) { if( !sockerr_again() ) { closesocket( req->fd ); goto error; } } } if( st > 0 ) req->bytes_written += st; if( req->bytes_written < req->request_length ) req->inpa = b_input_add( source, req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_WRITE, http_connected, req ); else req->inpa = b_input_add( source, GAIM_INPUT_READ, http_incoming_data, req ); return FALSE; error: req->status_string = g_strdup( "Error while writing HTTP request" ); req->func( req ); g_free( req->request ); g_free( req ); return FALSE; } static gboolean http_ssl_connected( gpointer data, void *source, b_input_condition cond ) { struct http_request *req = data; if( source == NULL ) return http_connected( data, -1, cond ); req->fd = ssl_getfd( source ); return http_connected( data, req->fd, cond ); } static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond ) { struct http_request *req = data; int evil_server = 0; char buffer[2048]; char *end1, *end2; int st; if( req->inpa > 0 ) b_event_remove( req->inpa ); if( req->ssl ) { st = ssl_read( req->ssl, buffer, sizeof( buffer ) ); if( st < 0 ) { if( ssl_errno != SSL_AGAIN ) { /* goto cleanup; */ /* YAY! We have to deal with crappy Microsoft servers that LOVE to send invalid TLS packets that abort connections! \o/ */ goto got_reply; } } else if( st == 0 ) { goto got_reply; } } else { st = read( req->fd, buffer, sizeof( buffer ) ); if( st < 0 ) { if( !sockerr_again() ) { req->status_string = g_strdup( strerror( errno ) ); goto cleanup; } } else if( st == 0 ) { goto got_reply; } } if( st > 0 ) { req->reply_headers = g_realloc( req->reply_headers, req->bytes_read + st + 1 ); memcpy( req->reply_headers + req->bytes_read, buffer, st ); req->bytes_read += st; } /* There will be more! */ req->inpa = b_input_add( req->fd, req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_READ, http_incoming_data, req ); return FALSE; got_reply: /* Maybe if the webserver is overloaded, or when there's bad SSL support... */ if( req->bytes_read == 0 ) { req->status_string = g_strdup( "Empty HTTP reply" ); goto cleanup; } /* Zero termination is very convenient. */ req->reply_headers[req->bytes_read] = 0; /* Find the separation between headers and body, and keep stupid webservers in mind. */ end1 = strstr( req->reply_headers, "\r\n\r\n" ); end2 = strstr( req->reply_headers, "\n\n" ); if( end2 && end2 < end1 ) { end1 = end2 + 1; evil_server = 1; } else if( end1 ) { end1 += 2; } else { req->status_string = g_strdup( "Malformed HTTP reply" ); goto cleanup; } *end1 = 0; if( evil_server ) req->reply_body = end1 + 1; else req->reply_body = end1 + 2; req->body_size = req->reply_headers + req->bytes_read - req->reply_body; if( ( end1 = strchr( req->reply_headers, ' ' ) ) != NULL ) { if( sscanf( end1 + 1, "%d", &req->status_code ) != 1 ) { req->status_string = g_strdup( "Can't parse status code" ); req->status_code = -1; } else { char *eol; if( evil_server ) eol = strchr( end1, '\n' ); else eol = strchr( end1, '\r' ); req->status_string = g_strndup( end1 + 1, eol - end1 - 1 ); /* Just to be sure... */ if( ( eol = strchr( req->status_string, '\r' ) ) ) *eol = 0; if( ( eol = strchr( req->status_string, '\n' ) ) ) *eol = 0; } } else { req->status_string = g_strdup( "Can't locate status code" ); req->status_code = -1; } if( req->status_code == 301 || req->status_code == 302 ) { char *loc, *new_request, *new_host; int error = 0, new_port, new_proto; /* We might fill it again, so let's not leak any memory. */ g_free( req->status_string ); req->status_string = NULL; loc = strstr( req->reply_headers, "\nLocation: " ); if( loc == NULL ) /* We can't handle this redirect... */ { req->status_string = g_strdup( "Can't locate Location: header" ); goto cleanup; } loc += 11; while( *loc == ' ' ) loc ++; /* TODO/FIXME: Possibly have to handle relative redirections, and rewrite Host: headers. Not necessary for now, it's enough for passport authentication like this. */ if( *loc == '/' ) { /* Just a different pathname... */ /* Since we don't cache the servername, and since we don't need this yet anyway, I won't implement it. */ req->status_string = g_strdup( "Can't handle recursive redirects" ); goto cleanup; } else { /* A whole URL */ url_t *url; char *s; s = strstr( loc, "\r\n" ); if( s == NULL ) goto cleanup; url = g_new0( url_t, 1 ); *s = 0; if( !url_set( url, loc ) ) { req->status_string = g_strdup( "Malformed redirect URL" ); g_free( url ); goto cleanup; } /* Okay, this isn't fun! We have to rebuild the request... :-( */ new_request = g_malloc( req->request_length + strlen( url->file ) ); /* So, now I just allocated enough memory, so I'm going to use strcat(), whether you like it or not. :-) */ sprintf( new_request, "GET %s HTTP/1.0", url->file ); s = strstr( req->request, "\r\n" ); if( s == NULL ) { req->status_string = g_strdup( "Error while rebuilding request string" ); g_free( new_request ); g_free( url ); goto cleanup; } strcat( new_request, s ); new_host = g_strdup( url->host ); new_port = url->port; new_proto = url->proto; g_free( url ); } if( req->ssl ) ssl_disconnect( req->ssl ); else closesocket( req->fd ); req->fd = -1; req->ssl = NULL; if( new_proto == PROTO_HTTPS ) { req->ssl = ssl_connect( new_host, new_port, http_ssl_connected, req ); if( req->ssl == NULL ) error = 1; } else { req->fd = proxy_connect( new_host, new_port, http_connected, req ); if( req->fd < 0 ) error = 1; } g_free( new_host ); if( error ) { req->status_string = g_strdup( "Connection problem during redirect" ); g_free( new_request ); goto cleanup; } g_free( req->request ); g_free( req->reply_headers ); req->request = new_request; req->request_length = strlen( new_request ); req->bytes_read = req->bytes_written = req->inpa = 0; req->reply_headers = req->reply_body = NULL; return FALSE; } /* Assume that a closed connection means we're finished, this indeed breaks with keep-alive connections and faulty connections. */ req->finished = 1; cleanup: if( req->ssl ) ssl_disconnect( req->ssl ); else closesocket( req->fd ); req->func( req ); g_free( req->request ); g_free( req->reply_headers ); g_free( req->status_string ); g_free( req ); return FALSE; }