Project

General

Profile

Feature #2163 » mod_mysql_vhost.c

Modified version of mod_vhost_mysql.c changed from the file of 1.4.19 - phpmysqlfreak, 2010-02-11 19:25

 
1
#include <unistd.h>
2
#include <stdio.h>
3
#include <errno.h>
4
#include <fcntl.h>
5
#include <strings.h>
6

    
7
#ifdef HAVE_CONFIG_H
8
#include "config.h"
9
#endif
10

    
11
#ifdef HAVE_MYSQL
12
#include <mysql.h>
13
#endif
14

    
15
#include "plugin.h"
16
#include "log.h"
17

    
18
#include "stat_cache.h"
19
#ifdef DEBUG_MOD_MYSQL_VHOST
20
#define DEBUG
21
#endif
22

    
23
/*
24
 * Plugin for lighttpd to use MySQL
25
 *   for domain to directory lookups,
26
 *   i.e virtual hosts (vhosts).
27
 *
28
 * Optionally sets fcgi_offset and fcgi_arg
29
 *   in preparation for fcgi.c to handle
30
 *   per-user fcgi chroot jails.
31
 *
32
 * /ada@riksnet.se 2004-12-06
33
 */
34

    
35
#ifdef HAVE_MYSQL
36
typedef struct {
37
	MYSQL 	*mysql;
38

    
39
	buffer  *mydb;
40
	buffer  *myuser;
41
	buffer  *mypass;
42
	buffer  *mysock;
43

    
44
	buffer  *hostname;
45
	unsigned short port;
46

    
47
	buffer  *mysql_pre;
48
	buffer  *mysql_mid;
49
	buffer  *mysql_post;
50
} plugin_config;
51

    
52
/* global plugin data */
53
typedef struct {
54
	PLUGIN_DATA;
55

    
56
	buffer 	*tmp_buf;
57

    
58
	plugin_config **config_storage;
59

    
60
	plugin_config conf;
61
} plugin_data;
62

    
63
/* per connection plugin data */
64
typedef struct {
65
	buffer	*server_name;
66
	buffer	*document_root;
67
	buffer	*fcgi_arg;
68
	unsigned fcgi_offset;
69
} plugin_connection_data;
70

    
71
/* init the plugin data */
72
INIT_FUNC(mod_mysql_vhost_init) {
73
	plugin_data *p;
74

    
75
	p = calloc(1, sizeof(*p));
76

    
77
	p->tmp_buf = buffer_init();
78

    
79
	return p;
80
}
81

    
82
/* cleanup the plugin data */
83
SERVER_FUNC(mod_mysql_vhost_cleanup) {
84
	plugin_data *p = p_d;
85

    
86
	UNUSED(srv);
87

    
88
#ifdef DEBUG
89
	log_error_write(srv, __FILE__, __LINE__, "ss",
90
		"mod_mysql_vhost_cleanup", p ? "yes" : "NO");
91
#endif
92
	if (!p) return HANDLER_GO_ON;
93

    
94
	if (p->config_storage) {
95
		size_t i;
96
		for (i = 0; i < srv->config_context->used; i++) {
97
			plugin_config *s = p->config_storage[i];
98

    
99
			if (!s) continue;
100

    
101
			mysql_close(s->mysql);
102

    
103
			buffer_free(s->mydb);
104
			buffer_free(s->myuser);
105
			buffer_free(s->mypass);
106
			buffer_free(s->mysock);
107
			buffer_free(s->mysql_pre);
108
			buffer_free(s->mysql_mid);
109
			buffer_free(s->mysql_post);
110
			buffer_free(s->hostname);
111

    
112
			free(s);
113
		}
114
		free(p->config_storage);
115
	}
116
	buffer_free(p->tmp_buf);
117

    
118
	free(p);
119

    
120
	return HANDLER_GO_ON;
121
}
122

    
123
/* handle the plugin per connection data */
124
static void* mod_mysql_vhost_connection_data(server *srv, connection *con, void *p_d)
125
{
126
	plugin_data *p = p_d;
127
	plugin_connection_data *c = con->plugin_ctx[p->id];
128

    
129
	UNUSED(srv);
130

    
131
#ifdef DEBUG
132
        log_error_write(srv, __FILE__, __LINE__, "ss",
133
		"mod_mysql_connection_data", c ? "old" : "NEW");
134
#endif
135

    
136
	if (c) return c;
137
	c = calloc(1, sizeof(*c));
138

    
139
	c->server_name = buffer_init();
140
	c->document_root = buffer_init();
141
	c->fcgi_arg = buffer_init();
142
	c->fcgi_offset = 0;
143

    
144
	return con->plugin_ctx[p->id] = c;
145
}
146

    
147
/* destroy the plugin per connection data */
148
CONNECTION_FUNC(mod_mysql_vhost_handle_connection_close) {
149
	plugin_data *p = p_d;
150
	plugin_connection_data *c = con->plugin_ctx[p->id];
151

    
152
	UNUSED(srv);
153

    
154
#ifdef DEBUG
155
	log_error_write(srv, __FILE__, __LINE__, "ss",
156
		"mod_mysql_vhost_handle_connection_close", c ? "yes" : "NO");
157
#endif
158

    
159
	if (!c) return HANDLER_GO_ON;
160

    
161
	buffer_free(c->server_name);
162
	buffer_free(c->document_root);
163
	buffer_free(c->fcgi_arg);
164
	c->fcgi_offset = 0;
165

    
166
	free(c);
167

    
168
	con->plugin_ctx[p->id] = NULL;
169
	return HANDLER_GO_ON;
170
}
171

    
172
/* set configuration values */
173
SERVER_FUNC(mod_mysql_vhost_set_defaults) {
174
	plugin_data *p = p_d;
175

    
176
	char *qmarkA;
177
	char *qmarkB;
178
	size_t i = 0;
179

    
180
	config_values_t cv[] = {
181
		{ "mysql-vhost.db",	NULL, T_CONFIG_STRING, 	T_CONFIG_SCOPE_SERVER },
182
		{ "mysql-vhost.user",	NULL, T_CONFIG_STRING, 	T_CONFIG_SCOPE_SERVER },
183
		{ "mysql-vhost.pass",	NULL, T_CONFIG_STRING, 	T_CONFIG_SCOPE_SERVER },
184
		{ "mysql-vhost.sock",	NULL, T_CONFIG_STRING, 	T_CONFIG_SCOPE_SERVER },
185
		{ "mysql-vhost.sql",	NULL, T_CONFIG_STRING, 	T_CONFIG_SCOPE_SERVER },
186
		{ "mysql-vhost.hostname", NULL, T_CONFIG_STRING,T_CONFIG_SCOPE_SERVER },
187
		{ "mysql-vhost.port",   NULL, T_CONFIG_SHORT,   T_CONFIG_SCOPE_SERVER },
188
                { NULL,			NULL, T_CONFIG_UNSET,	T_CONFIG_SCOPE_UNSET }
189
        };
190

    
191
	p->config_storage = calloc(1, srv->config_context->used * sizeof(specific_config *));
192

    
193
	for (i = 0; i < srv->config_context->used; i++) {
194
		plugin_config *s;
195
		buffer *sel;
196

    
197
		s = calloc(1, sizeof(plugin_config));
198
		s->mydb = buffer_init();
199
		s->myuser = buffer_init();
200
		s->mypass = buffer_init();
201
		s->mysock = buffer_init();
202
		s->hostname = buffer_init();
203
		s->port   = 0;               /* default port for mysql */
204
		sel = buffer_init();
205
		s->mysql = NULL;
206

    
207
		s->mysql_pre = buffer_init();
208
		s->mysql_mid = buffer_init();
209
		s->mysql_post = buffer_init();
210

    
211
		cv[0].destination = s->mydb;
212
		cv[1].destination = s->myuser;
213
		cv[2].destination = s->mypass;
214
		cv[3].destination = s->mysock;
215
		cv[4].destination = sel;
216
		cv[5].destination = s->hostname;
217
		cv[6].destination = &(s->port);
218

    
219
		p->config_storage[i] = s;
220

    
221
        	if (config_insert_values_global(srv,
222
			((data_config *)srv->config_context->data[i])->value,
223
			cv)) return HANDLER_ERROR;
224

    
225
		s->mysql_pre = buffer_init();
226
		s->mysql_mid = buffer_init();
227
		s->mysql_post = buffer_init();
228

    
229
		// quick dirty changed manually - parses 2 questionmarks:
230
		// the first - and the last. - hopefully
231
		if (sel->used && (qmarkA = strchr(sel->ptr, '?')) && (qmarkB = strrchr(sel->ptr, '?'))) {
232
			*qmarkA = '\0';
233
			*qmarkB = '\0';
234
			buffer_copy_string(s->mysql_pre, sel->ptr);
235
			buffer_copy_string(s->mysql_mid, qmarkA+1);
236
			buffer_copy_string(s->mysql_post, qmarkB+1);
237
		} else {
238
			buffer_copy_string_buffer(s->mysql_pre, sel);
239
		}
240
		
241
		/* Original-Code for Lines 231 to 239:
242
			if (sel->used && (qmark = strchr(sel->ptr, '?'))) {
243
				*qmark = '\0';
244
				buffer_copy_string(s->mysql_pre, sel->ptr);
245
				buffer_copy_string(s->mysql_post, qmark+1);
246
			} else {
247
				buffer_copy_string_buffer(s->mysql_pre, sel);
248
			}
249
		*/
250

    
251
		/* required:
252
		 * - username
253
		 * - database
254
		 *
255
		 * optional:
256
		 * - password, default: empty
257
		 * - socket, default: mysql default
258
		 * - hostname, if set overrides socket
259
		 * - port, default: 3306
260
		 */
261

    
262
		/* all have to be set */
263
		if (!(buffer_is_empty(s->myuser) ||
264
		      buffer_is_empty(s->mydb))) {
265
			my_bool reconnect = 1;
266
			int fd;
267

    
268
			if (NULL == (s->mysql = mysql_init(NULL))) {
269
				log_error_write(srv, __FILE__, __LINE__, "s", "mysql_init() failed, exiting...");
270

    
271
				return HANDLER_ERROR;
272
			}
273

    
274
#if MYSQL_VERSION_ID >= 50013
275
			/* in mysql versions above 5.0.3 the reconnect flag is off by default */
276
			mysql_options(s->mysql, MYSQL_OPT_RECONNECT, &reconnect);
277
#endif
278

    
279
#define FOO(x) (s->x->used ? s->x->ptr : NULL)
280

    
281
			if (!mysql_real_connect(s->mysql, FOO(hostname), FOO(myuser), FOO(mypass),
282
						FOO(mydb), s->port, FOO(mysock), 0)) {
283
				log_error_write(srv, __FILE__, __LINE__, "s", mysql_error(s->mysql));
284

    
285
				return HANDLER_ERROR;
286
			}
287
#undef FOO
288
			/* set close_on_exec for mysql the hard way */
289
			/* Note: this only works as it is done during startup, */
290
			/* otherwise we cannot be sure that mysql is fd i-1 */
291
			if (-1 == (fd = open("/dev/null", 0))) {
292
				close(fd);
293
				fcntl(fd-1, F_SETFD, FD_CLOEXEC);
294
			}
295
		}
296
	}
297

    
298

    
299

    
300
        return HANDLER_GO_ON;
301
}
302

    
303
#define PATCH(x) \
304
	p->conf.x = s->x;
305
static int mod_mysql_vhost_patch_connection(server *srv, connection *con, plugin_data *p) {
306
	size_t i, j;
307
	plugin_config *s = p->config_storage[0];
308

    
309
	PATCH(mysql_pre);
310
	PATCH(mysql_mid);
311
	PATCH(mysql_post);
312
#ifdef HAVE_MYSQL
313
	PATCH(mysql);
314
#endif
315

    
316
	/* skip the first, the global context */
317
	for (i = 1; i < srv->config_context->used; i++) {
318
		data_config *dc = (data_config *)srv->config_context->data[i];
319
		s = p->config_storage[i];
320

    
321
		/* condition didn't match */
322
		if (!config_check_cond(srv, con, dc)) continue;
323

    
324
		/* merge config */
325
		for (j = 0; j < dc->value->used; j++) {
326
			data_unset *du = dc->value->data[j];
327

    
328
			if (buffer_is_equal_string(du->key, CONST_STR_LEN("mysql-vhost.sql"))) {
329
				PATCH(mysql_pre);
330
				PATCH(mysql_mid);
331
				PATCH(mysql_post);
332
			}
333
		}
334

    
335
		if (s->mysql) {
336
			PATCH(mysql);
337
		}
338
	}
339

    
340
	return 0;
341
}
342
#undef PATCH
343

    
344

    
345
/* handle document root request */
346
CONNECTION_FUNC(mod_mysql_vhost_handle_docroot) {
347
	plugin_data *p = p_d;
348
	plugin_connection_data *c;
349
	stat_cache_entry *sce;
350

    
351
	unsigned  cols;
352
	MYSQL_ROW row;
353
	MYSQL_RES *result = NULL;
354

    
355
	/* no host specified? */
356
	if (!con->uri.authority->used) return HANDLER_GO_ON;
357

    
358
	mod_mysql_vhost_patch_connection(srv, con, p);
359

    
360
	if (!p->conf.mysql) return HANDLER_GO_ON;
361

    
362
	/* sets up connection data if not done yet */
363
	c = mod_mysql_vhost_connection_data(srv, con, p_d);
364

    
365
	/* check if cached this connection */
366
	if (c->server_name->used && /* con->uri.authority->used && */
367
             buffer_is_equal(c->server_name, con->uri.authority)) goto GO_ON;
368

    
369
	/* build and run SQL query */
370
	buffer_copy_string_buffer(p->tmp_buf, p->conf.mysql_pre);
371
	if (p->conf.mysql_mid->used) {
372
		buffer_append_string_buffer(p->tmp_buf, con->uri.authority);
373
		buffer_append_string_buffer(p->tmp_buf, p->conf.mysql_mid);
374
	}
375
	if (p->conf.mysql_post->used) {
376
		buffer_append_string_buffer(p->tmp_buf, con->uri.authority);
377
		buffer_append_string_buffer(p->tmp_buf, p->conf.mysql_post);
378
	}
379
  if (mysql_query(p->conf.mysql, p->tmp_buf->ptr)) {
380
		log_error_write(srv, __FILE__, __LINE__, "s", mysql_error(p->conf.mysql));
381
		goto ERR500;
382
	}
383
	result = mysql_store_result(p->conf.mysql);
384
	cols = mysql_num_fields(result);
385
	row = mysql_fetch_row(result);
386
	if (!row || cols < 1) {
387
		/* no such virtual host */
388
		mysql_free_result(result);
389
		return HANDLER_GO_ON;
390
	}
391

    
392
	/* sanity check that really is a directory */
393
	buffer_copy_string(p->tmp_buf, row[0]);
394
	BUFFER_APPEND_SLASH(p->tmp_buf);
395

    
396
	if (HANDLER_ERROR == stat_cache_get_entry(srv, con, p->tmp_buf, &sce)) {
397
		log_error_write(srv, __FILE__, __LINE__, "sb", strerror(errno), p->tmp_buf);
398
		goto ERR500;
399
	}
400
        if (!S_ISDIR(sce->st.st_mode)) {
401
		log_error_write(srv, __FILE__, __LINE__, "sb", "Not a directory", p->tmp_buf);
402
		goto ERR500;
403
	}
404

    
405
	/* cache the data */
406
	buffer_copy_string_buffer(c->server_name, con->uri.authority);
407
	buffer_copy_string_buffer(c->document_root, p->tmp_buf);
408

    
409
	/* fcgi_offset and fcgi_arg are optional */
410
	if (cols > 1 && row[1]) {
411
		c->fcgi_offset = atoi(row[1]);
412

    
413
		if (cols > 2 && row[2]) {
414
			buffer_copy_string(c->fcgi_arg, row[2]);
415
		} else {
416
			c->fcgi_arg->used = 0;
417
		}
418
	} else {
419
		c->fcgi_offset = c->fcgi_arg->used = 0;
420
	}
421
	mysql_free_result(result);
422

    
423
	/* fix virtual server and docroot */
424
GO_ON:	buffer_copy_string_buffer(con->server_name, c->server_name);
425
	buffer_copy_string_buffer(con->physical.doc_root, c->document_root);
426

    
427
#ifdef DEBUG
428
	log_error_write(srv, __FILE__, __LINE__, "sbbdb",
429
		result ? "NOT CACHED" : "cached",
430
		con->server_name, con->physical.doc_root,
431
		c->fcgi_offset, c->fcgi_arg);
432
#endif
433
	return HANDLER_GO_ON;
434

    
435
ERR500:	if (result) mysql_free_result(result);
436
	con->http_status = 500; /* Internal Error */
437
	return HANDLER_FINISHED;
438
}
439

    
440
/* this function is called at dlopen() time and inits the callbacks */
441
int mod_mysql_vhost_plugin_init(plugin *p) {
442
	p->version     = LIGHTTPD_VERSION_ID;
443
	p->name        			= buffer_init_string("mysql_vhost");
444

    
445
	p->init        			= mod_mysql_vhost_init;
446
	p->cleanup     			= mod_mysql_vhost_cleanup;
447
	p->handle_request_done	 	= mod_mysql_vhost_handle_connection_close;
448

    
449
	p->set_defaults			= mod_mysql_vhost_set_defaults;
450
	p->handle_docroot  		= mod_mysql_vhost_handle_docroot;
451

    
452
	return 0;
453
}
454
#else
455
/* we don't have mysql support, this plugin does nothing */
456
int mod_mysql_vhost_plugin_init(plugin *p) {
457
	p->version     = LIGHTTPD_VERSION_ID;
458
	p->name        			= buffer_init_string("mysql_vhost");
459

    
460
	return 0;
461
}
462
#endif
(1-1/4)