ClamAV INSTREAM scanning by default, unless built with WITH_OLD_CLAMAV_STREAM.
[exim.git] / src / src / lookups / mysql.c
1 /* $Cambridge: exim/src/src/lookups/mysql.c,v 1.7 2010/03/05 15:59:29 nm4 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* Thanks to Paul Kelly for contributing the original code for these
11 functions. */
12
13
14 #include "../exim.h"
15 #include "lf_functions.h"
16 #include "mysql.h"       /* The local header */
17
18
19 /* We can't just compile this code and allow the library mechanism to omit the
20 functions if they are not wanted, because we need to have the MYSQL header
21 available for compiling. Therefore, compile these functions only if
22 LOOKUP_MYSQL is defined. However, some compilers don't like compiling empty
23 modules, so keep them happy with a dummy when skipping the rest. Make it
24 reference itself to stop picky compilers complaining that it is unused, and put
25 in a dummy argument to stop even pickier compilers complaining about infinite
26 loops. */
27
28 #ifndef LOOKUP_MYSQL
29 static void dummy(int x) { dummy(x-1); }
30 #else
31
32
33 #include <mysql.h>       /* The system header */
34
35
36 /* Structure and anchor for caching connections. */
37
38 typedef struct mysql_connection {
39   struct mysql_connection *next;
40   uschar  *server;
41   MYSQL *handle;
42 } mysql_connection;
43
44 static mysql_connection *mysql_connections = NULL;
45
46
47
48 /*************************************************
49 *              Open entry point                  *
50 *************************************************/
51
52 /* See local README for interface description. */
53
54 void *
55 mysql_open(uschar *filename, uschar **errmsg)
56 {
57 return (void *)(1);    /* Just return something non-null */
58 }
59
60
61
62 /*************************************************
63 *               Tidy entry point                 *
64 *************************************************/
65
66 /* See local README for interface description. */
67
68 void
69 mysql_tidy(void)
70 {
71 mysql_connection *cn;
72 while ((cn = mysql_connections) != NULL)
73   {
74   mysql_connections = cn->next;
75   DEBUG(D_lookup) debug_printf("close MYSQL connection: %s\n", cn->server);
76   mysql_close(cn->handle);
77   }
78 }
79
80
81
82 /*************************************************
83 *        Internal search function                *
84 *************************************************/
85
86 /* This function is called from the find entry point to do the search for a
87 single server.
88
89 Arguments:
90   query        the query string
91   server       the server string
92   resultptr    where to store the result
93   errmsg       where to point an error message
94   defer_break  TRUE if no more servers are to be tried after DEFER
95   do_cache     set false if data is changed
96
97 The server string is of the form "host/dbname/user/password". The host can be
98 host:port. This string is in a nextinlist temporary buffer, so can be
99 overwritten.
100
101 Returns:       OK, FAIL, or DEFER
102 */
103
104 static int
105 perform_mysql_search(uschar *query, uschar *server, uschar **resultptr,
106   uschar **errmsg, BOOL *defer_break, BOOL *do_cache)
107 {
108 MYSQL *mysql_handle = NULL;        /* Keep compilers happy */
109 MYSQL_RES *mysql_result = NULL;
110 MYSQL_ROW mysql_row_data;
111 MYSQL_FIELD *fields;
112
113 int i;
114 int ssize = 0;
115 int offset = 0;
116 int yield = DEFER;
117 unsigned int num_fields;
118 uschar *result = NULL;
119 mysql_connection *cn;
120 uschar *server_copy = NULL;
121 uschar *sdata[4];
122
123 /* Disaggregate the parameters from the server argument. The order is host,
124 database, user, password. We can write to the string, since it is in a
125 nextinlist temporary buffer. The copy of the string that is used for caching
126 has the password removed. This copy is also used for debugging output. */
127
128 for (i = 3; i > 0; i--)
129   {
130   uschar *pp = Ustrrchr(server, '/');
131   if (pp == NULL)
132     {
133     *errmsg = string_sprintf("incomplete MySQL server data: %s",
134       (i == 3)? server : server_copy);
135     *defer_break = TRUE;
136     return DEFER;
137     }
138   *pp++ = 0;
139   sdata[i] = pp;
140   if (i == 3) server_copy = string_copy(server);  /* sans password */
141   }
142 sdata[0] = server;   /* What's left at the start */
143
144 /* See if we have a cached connection to the server */
145
146 for (cn = mysql_connections; cn != NULL; cn = cn->next)
147   {
148   if (Ustrcmp(cn->server, server_copy) == 0)
149     {
150     mysql_handle = cn->handle;
151     break;
152     }
153   }
154
155 /* If no cached connection, we must set one up. Mysql allows for a host name
156 and port to be specified. It also allows the name of a Unix socket to be used.
157 Unfortunately, this contains slashes, but its use is expected to be rare, so
158 the rather cumbersome syntax shouldn't inconvenience too many people. We use
159 this:  host:port(socket)  where all the parts are optional. */
160
161 if (cn == NULL)
162   {
163   uschar *p;
164   uschar *socket = NULL;
165   int port = 0;
166
167   if ((p = Ustrchr(sdata[0], '(')) != NULL)
168     {
169     *p++ = 0;
170     socket = p;
171     while (*p != 0 && *p != ')') p++;
172     *p = 0;
173     }
174
175   if ((p = Ustrchr(sdata[0], ':')) != NULL)
176     {
177     *p++ = 0;
178     port = Uatoi(p);
179     }
180
181   if (Ustrchr(sdata[0], '/') != NULL)
182     {
183     *errmsg = string_sprintf("unexpected slash in MySQL server hostname: %s",
184       sdata[0]);
185     *defer_break = TRUE;
186     return DEFER;
187     }
188
189   /* If the database is the empty string, set it NULL - the query must then
190   define it. */
191
192   if (sdata[1][0] == 0) sdata[1] = NULL;
193
194   DEBUG(D_lookup)
195     debug_printf("MYSQL new connection: host=%s port=%d socket=%s "
196       "database=%s user=%s\n", sdata[0], port, socket, sdata[1], sdata[2]);
197
198   /* Get store for a new handle, initialize it, and connect to the server */
199
200   mysql_handle = store_get(sizeof(MYSQL));
201   mysql_init(mysql_handle);
202   if (mysql_real_connect(mysql_handle,
203       /*  host        user         passwd     database */
204       CS sdata[0], CS sdata[2], CS sdata[3], CS sdata[1],
205       port, CS socket, CLIENT_MULTI_RESULTS) == NULL)
206     {
207     *errmsg = string_sprintf("MYSQL connection failed: %s",
208       mysql_error(mysql_handle));
209     *defer_break = FALSE;
210     goto MYSQL_EXIT;
211     }
212
213   /* Add the connection to the cache */
214
215   cn = store_get(sizeof(mysql_connection));
216   cn->server = server_copy;
217   cn->handle = mysql_handle;
218   cn->next = mysql_connections;
219   mysql_connections = cn;
220   }
221
222 /* Else use a previously cached connection */
223
224 else
225   {
226   DEBUG(D_lookup)
227     debug_printf("MYSQL using cached connection for %s\n", server_copy);
228   }
229
230 /* Run the query */
231
232 if (mysql_query(mysql_handle, CS query) != 0)
233   {
234   *errmsg = string_sprintf("MYSQL: query failed: %s\n",
235     mysql_error(mysql_handle));
236   *defer_break = FALSE;
237   goto MYSQL_EXIT;
238   }
239
240 /* Pick up the result. If the query was not of the type that returns data,
241 namely INSERT, UPDATE, or DELETE, an error occurs here. However, this situation
242 can be detected by calling mysql_field_count(). If its result is zero, no data
243 was expected (this is all explained clearly in the MySQL manual). In this case,
244 we return the number of rows affected by the command. In this event, we do NOT
245 want to cache the result; also the whole cache for the handle must be cleaned
246 up. Setting do_cache FALSE requests this. */
247
248 if ((mysql_result = mysql_use_result(mysql_handle)) == NULL)
249   {
250   if ( mysql_field_count(mysql_handle) == 0 )
251     {
252     DEBUG(D_lookup) debug_printf("MYSQL: query was not one that returns data\n");
253     result = string_sprintf("%d", mysql_affected_rows(mysql_handle));
254     *do_cache = FALSE;
255     goto MYSQL_EXIT;
256     }
257   *errmsg = string_sprintf("MYSQL: lookup result failed: %s\n",
258     mysql_error(mysql_handle));
259   *defer_break = FALSE;
260   goto MYSQL_EXIT;
261   }
262
263 /* Find the number of fields returned. If this is one, we don't add field
264 names to the data. Otherwise we do. */
265
266 num_fields = mysql_num_fields(mysql_result);
267
268 /* Get the fields and construct the result string. If there is more than one
269 row, we insert '\n' between them. */
270
271 fields = mysql_fetch_fields(mysql_result);
272
273 while ((mysql_row_data = mysql_fetch_row(mysql_result)) != NULL)
274   {
275   unsigned long *lengths = mysql_fetch_lengths(mysql_result);
276
277   if (result != NULL)
278       result = string_cat(result, &ssize, &offset, US"\n", 1);
279
280   if (num_fields == 1)
281     {
282     if (mysql_row_data[0] != NULL)    /* NULL value yields nothing */
283       result = string_cat(result, &ssize, &offset, US mysql_row_data[0],
284         lengths[0]);
285     }
286
287   else for (i = 0; i < num_fields; i++)
288     {
289     result = lf_quote(US fields[i].name, US mysql_row_data[i], lengths[i],
290       result, &ssize, &offset);
291     }
292   }
293
294 /* more results? -1 = no, >0 = error, 0 = yes (keep looping)
295    This is needed because of the CLIENT_MULTI_RESULTS on mysql_real_connect(),
296    we don't expect any more results. */
297
298 while((i = mysql_next_result(mysql_handle)) >= 0) {
299    if(i == 0) {   /* Just ignore more results */
300      DEBUG(D_lookup) debug_printf("MYSQL: got unexpected more results\n");
301      continue;
302    }
303
304    *errmsg = string_sprintf("MYSQL: lookup result error when checking for more results: %s\n",
305        mysql_error(mysql_handle));
306    goto MYSQL_EXIT;
307 }
308
309 /* If result is NULL then no data has been found and so we return FAIL.
310 Otherwise, we must terminate the string which has been built; string_cat()
311 always leaves enough room for a terminating zero. */
312
313 if (result == NULL)
314   {
315   yield = FAIL;
316   *errmsg = US"MYSQL: no data found";
317   }
318 else
319   {
320   result[offset] = 0;
321   store_reset(result + offset + 1);
322   }
323
324 /* Get here by goto from various error checks and from the case where no data
325 was read (e.g. an update query). */
326
327 MYSQL_EXIT:
328
329 /* Free mysal store for any result that was got; don't close the connection, as
330 it is cached. */
331
332 if (mysql_result != NULL) mysql_free_result(mysql_result);
333
334 /* Non-NULL result indicates a sucessful result */
335
336 if (result != NULL)
337   {
338   *resultptr = result;
339   return OK;
340   }
341 else
342   {
343   DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
344   return yield;      /* FAIL or DEFER */
345   }
346 }
347
348
349
350
351 /*************************************************
352 *               Find entry point                 *
353 *************************************************/
354
355 /* See local README for interface description. The handle and filename
356 arguments are not used. The code to loop through a list of servers while the
357 query is deferred with a retryable error is now in a separate function that is
358 shared with other SQL lookups. */
359
360 int
361 mysql_find(void *handle, uschar *filename, uschar *query, int length,
362   uschar **result, uschar **errmsg, BOOL *do_cache)
363 {
364 return lf_sqlperform(US"MySQL", US"mysql_servers", mysql_servers, query,
365   result, errmsg, do_cache, perform_mysql_search);
366 }
367
368
369
370 /*************************************************
371 *               Quote entry point                *
372 *************************************************/
373
374 /* The only characters that need to be quoted (with backslash) are newline,
375 tab, carriage return, backspace, backslash itself, and the quote characters.
376 Percent, and underscore and not escaped. They are only special in contexts
377 where they can be wild cards, and this isn't usually the case for data inserted
378 from messages, since that isn't likely to be treated as a pattern of any kind.
379 Sadly, MySQL doesn't seem to behave like other programs. If you use something
380 like "where id="ab\%cd" it does not treat the string as "ab%cd". So you really
381 can't quote "on spec".
382
383 Arguments:
384   s          the string to be quoted
385   opt        additional option text or NULL if none
386
387 Returns:     the processed string or NULL for a bad option
388 */
389
390 uschar *
391 mysql_quote(uschar *s, uschar *opt)
392 {
393 register int c;
394 int count = 0;
395 uschar *t = s;
396 uschar *quoted;
397
398 if (opt != NULL) return NULL;     /* No options recognized */
399
400 while ((c = *t++) != 0)
401   if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL) count++;
402
403 if (count == 0) return s;
404 t = quoted = store_get(Ustrlen(s) + count + 1);
405
406 while ((c = *s++) != 0)
407   {
408   if (Ustrchr("\n\t\r\b\'\"\\", c) != NULL)
409     {
410     *t++ = '\\';
411     switch(c)
412       {
413       case '\n': *t++ = 'n';
414       break;
415       case '\t': *t++ = 't';
416       break;
417       case '\r': *t++ = 'r';
418       break;
419       case '\b': *t++ = 'b';
420       break;
421       default:   *t++ = c;
422       break;
423       }
424     }
425   else *t++ = c;
426   }
427
428 *t = 0;
429 return quoted;
430 }
431
432
433 #endif  /* MYSQL_LOOKUP */
434
435 /* End of lookups/mysql.c */