File: mod_log_sql_dbi.c

package info (click to toggle)
libapache-mod-log-sql 1.100-16.3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid, stretch
  • size: 1,168 kB
  • ctags: 622
  • sloc: sh: 2,470; ansic: 2,264; xml: 2,010; makefile: 322; perl: 250; sql: 64
file content (268 lines) | stat: -rw-r--r-- 7,771 bytes parent folder | download | duplicates (3)
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
/* $Id: mod_log_sql_dbi.c 120 2004-04-17 15:14:12Z urkle@drip.ws $ */

#if defined(WITH_APACHE20)
#	include "apache20.h"
#elif defined(WITH_APACHE13)
#	include "apache13.h"
#else
#	error Unsupported Apache version
#endif


#ifdef HAVE_CONFIG_H
/* Undefine these to prevent conflicts between Apache ap_config_auto.h and 
 * my config.h. Only really needed for Apache < 2.0.48, but it can't hurt.
 */
#undef PACKAGE_BUGREPORT
#undef PACKAGE_NAME
#undef PACKAGE_STRING
#undef PACKAGE_TARNAME
#undef PACKAGE_VERSION

#include "config.h"
#endif

#include "mod_log_sql.h"

#include "dbi/dbi.h"

typedef struct {
	dbi_conn conn;
} dbi_conn_rec;

/* Connect to the MYSQL database */
static logsql_opendb_ret log_sql_dbi_connect(server_rec *s, logsql_dbconnection *db)
{
    const char *driver = apr_table_get(db->parms,"driver");
	const char *host = apr_table_get(db->parms,"hostname");
	const char *user = apr_table_get(db->parms,"username");
	const char *passwd = apr_table_get(db->parms,"password");
	const char *database = apr_table_get(db->parms,"database");
	const char *s_tcpport = apr_table_get(db->parms,"port");
	unsigned int tcpport = (s_tcpport)?atoi(s_tcpport):0;
	const char *socketfile = apr_table_get(db->parms,"socketfile");
    //dbi_result result;
    dbi_conn_rec *dblink = db->handle;
    if (!dblink) {
        dblink = apr_pcalloc(db->p, sizeof(*dblink));
        db->handle = (void *)dblink;
    }

	dblink->conn = dbi_conn_new(driver);

    dbi_conn_set_option(dblink->conn, "host", host);
    dbi_conn_set_option(dblink->conn, "username", user);
    dbi_conn_set_option(dblink->conn, "password", passwd);
    dbi_conn_set_option(dblink->conn, "dbname", database);
    if (tcpport) {
        dbi_conn_set_option_numeric(dblink->conn, "port", tcpport);
    }

	if (socketfile && !strcmp(driver,"mysql")) {
		dbi_conn_set_option(dblink->conn, "mysql_unix_socket", socketfile);
	}
    
	if (!dbi_conn_connect(dblink->conn)) {
		log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
            "HOST: '%s' PORT: '%d' DB: '%s' USER: '%s' SOCKET: '%s'",
			host, tcpport, database, user, socketfile);
		return LOGSQL_OPENDB_SUCCESS;
	} else {
        const char *error;
        dbi_conn_error(dblink->conn, &error);
		log_error(APLOG_MARK, APLOG_ERR, 0, s,
            "DBI Error: %s", error);
		log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
            "HOST: '%s' PORT: '%d' DB: '%s' USER: '%s' SOCKET: '%s'",
			host, tcpport, database, user, socketfile);
		return LOGSQL_OPENDB_FAIL;
	}
}

/* Close the DB link */
static void log_sql_dbi_close(logsql_dbconnection *db)
{
    dbi_conn_rec *dblink = db->handle;
    dbi_conn_close(dblink->conn);
    dblink->conn = NULL;
}

/* Routine to escape the 'dangerous' characters that would otherwise
 * corrupt the INSERT string: ', \, and "
 */
static const char *log_sql_dbi_escape(const char *from_str, apr_pool_t *p, 
								logsql_dbconnection *db)
{
    dbi_conn_rec *dblink = db->handle;

	if (!from_str)
		return NULL;
	else {
        char *to_str = strdup(from_str);
        char *retval;
        dbi_driver_quote_string(dbi_conn_get_driver(dblink->conn), &to_str);
        retval = apr_pstrdup(p, to_str);
        free(to_str);
        return retval;
	}
}

/* Run a mysql insert query and return a categorized error or success */
static logsql_query_ret log_sql_dbi_query(request_rec *r,logsql_dbconnection *db,
								const char *query)
{
    const char *error;
    dbi_result result;
	dbi_conn_rec *dblink = db->handle;

	if (!dblink->conn) {
		return LOGSQL_QUERY_NOLINK;
	}

	/* Run the query */
	if ((result = dbi_conn_query(dblink->conn, query))) {
		return LOGSQL_QUERY_SUCCESS;
	}
	/* Check to see if the error is "nonexistent table" */
	dbi_conn_error(dblink->conn, &error);
    log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
        "DBI Error: %s", error);
/*	if (real_error == ER_NO_SUCH_TABLE) {
		log_error(APLOG_MARK,APLOG_ERR,0, r->server,"table does not exist, preserving query");
		return LOGSQL_QUERY_NOTABLE;
	}*/
	return LOGSQL_QUERY_FAIL;
}

/* Create table table_name of type table_type. */
static logsql_table_ret log_sql_dbi_create(request_rec *r, logsql_dbconnection *db,
						logsql_tabletype table_type, const char *table_name)
{
	dbi_result result;
    const char *driver = apr_table_get(db->parms,"driver");
	const char *tabletype = apr_table_get(db->parms,"tabletype");
	char *type_suffix = NULL;

	char *create_prefix = "create table if not exists `";
	char *create_suffix = NULL;
	char *create_sql;

	dbi_conn_rec *dblink = db->handle;

/*	if (!global_config.createtables) {
		return APR_SUCCESS;
	}*/

	switch (table_type) {
	case LOGSQL_TABLE_ACCESS:
		create_suffix = 
	"` (id char(19),\
       agent varchar(255),\
       bytes_sent int unsigned,\
       child_pid smallint unsigned,\
       cookie varchar(255),\
	   machine_id varchar(25),\
       request_file varchar(255),\
       referer varchar(255),\
       remote_host varchar(50),\
       remote_logname varchar(50),\
       remote_user varchar(50),\
       request_duration smallint unsigned,\
       request_line varchar(255),\
       request_method varchar(10),\
       request_protocol varchar(10),\
       request_time char(28),\
       request_uri varchar(255),\
	   request_args varchar(255),\
       server_port smallint unsigned,\
       ssl_cipher varchar(25),\
       ssl_keysize smallint unsigned,\
       ssl_maxkeysize smallint unsigned,\
       status smallint unsigned,\
       time_stamp int unsigned,\
       virtual_host varchar(255))";
		break;
	case LOGSQL_TABLE_COOKIES:
	case LOGSQL_TABLE_HEADERSIN:
	case LOGSQL_TABLE_HEADERSOUT:
	case LOGSQL_TABLE_NOTES:
		create_suffix = 
	"` (id char(19),\
	   item varchar(80),\
	   val varchar(80))";
		break;
	}
	
	if (tabletype && !strcmp(driver,"mysql")) {
		type_suffix = apr_pstrcat(r->pool, " TYPE=", 
							tabletype, NULL);
	}
	/* Find memory long enough to hold the whole CREATE string + \0 */
	create_sql = apr_pstrcat(r->pool, create_prefix, table_name, create_suffix,
						type_suffix, NULL);

	log_error(APLOG_MARK,APLOG_DEBUG,0, r->server,"create string: %s", create_sql);

	if (!dblink) {
		return LOGSQL_QUERY_NOLINK;
	}

	/* Run the create query */
  	if (!(result = dbi_conn_query(dblink, create_sql))) {
        const char *error;
        dbi_conn_error(dblink->conn, &error);
		log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
            "DBI Error: %s", error);
		return LOGSQL_TABLE_FAIL;
	}

	return LOGSQL_TABLE_SUCCESS;
}

static char *make_dbi_ignore_insert(char * insert_query, request_rec *r) {
	return apr_psprintf(r->pool, "insert ignore into %s ;",insert_query);
}

static logsql_dbdriver log_sql_dbi_driver = {
    "dbi",
	NULL,
	log_sql_dbi_connect,	/* open DB connection */
	log_sql_dbi_close,	/* close DB connection */
	log_sql_dbi_escape,	/* escape query */
	log_sql_dbi_query,	/* insert query */
	log_sql_dbi_create,	/* create table */
	make_dbi_ignore_insert /* insert ignore */
};

static apr_status_t log_sql_dbi_cleanup(void *data)
{
    dbi_shutdown();
#if defined(WITH_APACHE20)
    return APR_SUCCESS;
#endif
}

LOGSQL_REGISTER(dbi) {
    dbi_driver driver;
    const char **driver_list;
    int count = 1;

    dbi_initialize(NULL);

    for (driver = dbi_driver_list(NULL);
            driver;
            driver = dbi_driver_list(driver)) {
        count++;
    }
    driver_list = apr_pcalloc(p, sizeof(char *) * (count));
    count = 0;
    for (driver = dbi_driver_list(NULL);
            driver;
            driver = dbi_driver_list(driver)) {
        driver_list[count++] = dbi_driver_get_name(driver);
    }
    log_sql_dbi_driver.provided_drivers = driver_list;
	log_sql_register_driver(p,&log_sql_dbi_driver);
    apr_pool_cleanup_register(p, NULL, log_sql_dbi_cleanup, NULL);
	LOGSQL_REGISTER_RETURN;
}