← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/query.cc

  • Committer: Brian Aker
  • Date: 2011-12-19 16:28:27 UTC
  • mto: (2478.1.1 drizzle-build)
  • mto: This revision was merged to the branch mainline in revision 2478.
  • Revision ID: brian@tangent.org-20111219162827-bfwc9zzfk10omyil
Null safety fix for libdrizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/query.cc
55
55
                                     const char *query, 
56
56
                                     drizzle_return_t *ret_ptr)
57
57
{
58
 
  size_t size;
 
58
  if (query == NULL)
 
59
  {
 
60
    return NULL;
 
61
  }
59
62
 
60
 
  size= strlen(query);
 
63
  size_t size= strlen(query);
61
64
 
62
65
  return drizzle_con_command_write(con, result, DRIZZLE_COMMAND_QUERY,
63
66
                                   (uint8_t *)query, size, size, ret_ptr);
80
83
                                    drizzle_query_options_t options,
81
84
                                    void *context)
82
85
{
 
86
  if (drizzle == NULL)
 
87
  {
 
88
    return NULL;
 
89
  }
 
90
 
83
91
  query= drizzle_query_create(drizzle, query);
84
92
  if (query == NULL)
 
93
  {
85
94
    return NULL;
 
95
  }
86
96
 
87
97
  drizzle_query_set_con(query, con);
88
98
  drizzle_query_set_result(query, result);
96
106
drizzle_query_st *drizzle_query_create(drizzle_st *drizzle,
97
107
                                       drizzle_query_st *query)
98
108
{
 
109
  if (drizzle == NULL)
 
110
  {
 
111
    return NULL;
 
112
  }
 
113
 
99
114
  if (query == NULL)
100
115
  {
101
116
    query= new (std::nothrow) drizzle_query_st;
109
124
    query->options|= DRIZZLE_CON_ALLOCATED;
110
125
  }
111
126
  else
 
127
  {
112
128
    memset(query, 0, sizeof(drizzle_query_st));
 
129
  }
113
130
 
114
131
  query->drizzle= drizzle;
115
132
 
125
142
 
126
143
void drizzle_query_free(drizzle_query_st *query)
127
144
{
 
145
  if (query == NULL)
 
146
  {
 
147
    return;
 
148
  }
 
149
 
128
150
  if (query->context != NULL && query->context_free_fn != NULL)
129
151
    query->context_free_fn(query, query->context);
130
152
 
131
153
  if (query->drizzle->query_list == query)
132
154
    query->drizzle->query_list= query->next;
 
155
 
133
156
  if (query->prev)
134
157
    query->prev->next= query->next;
 
158
 
135
159
  if (query->next)
136
160
    query->next->prev= query->prev;
137
161
  query->drizzle->query_count--;
144
168
 
145
169
void drizzle_query_free_all(drizzle_st *drizzle)
146
170
{
 
171
  if (drizzle == NULL)
 
172
  {
 
173
    return;
 
174
  }
 
175
 
147
176
  while (drizzle->query_list != NULL)
148
177
  {
149
178
    drizzle_query_free(drizzle->query_list);
152
181
 
153
182
drizzle_con_st *drizzle_query_con(drizzle_query_st *query)
154
183
{
 
184
  if (query == NULL)
 
185
  {
 
186
    return NULL;
 
187
  }
 
188
 
155
189
  return query->con;
156
190
}
157
191
 
158
192
void drizzle_query_set_con(drizzle_query_st *query, drizzle_con_st *con)
159
193
{
 
194
  if (query == NULL)
 
195
  {
 
196
    return;
 
197
  }
 
198
 
160
199
  query->con= con;
161
200
}
162
201
 
163
202
drizzle_result_st *drizzle_query_result(drizzle_query_st *query)
164
203
{
 
204
  if (query == NULL)
 
205
  {
 
206
    return NULL;
 
207
  }
 
208
 
165
209
  return query->result;
166
210
}
167
211
 
168
212
void drizzle_query_set_result(drizzle_query_st *query,
169
213
                              drizzle_result_st *result)
170
214
{
 
215
  if (query == NULL)
 
216
  {
 
217
    return;
 
218
  }
 
219
 
171
220
  query->result= result;
172
221
}
173
222
 
174
223
char *drizzle_query_string(drizzle_query_st *query, size_t *size)
175
224
{
176
 
  *size= query->size;
 
225
  if (query == NULL)
 
226
  {
 
227
    return NULL;
 
228
  }
 
229
 
 
230
  if (size)
 
231
  {
 
232
    *size= query->size;
 
233
  }
 
234
 
177
235
  return (char *)(query->string);
178
236
}
179
237
 
180
238
void drizzle_query_set_string(drizzle_query_st *query, const char *string,
181
239
                              size_t size)
182
240
{
 
241
  if (query == NULL)
 
242
  {
 
243
    return;
 
244
  }
 
245
 
183
246
  query->string= string;
184
247
  query->size= size;
185
248
}
186
249
 
187
250
drizzle_query_options_t drizzle_query_options(drizzle_query_st *query)
188
251
{
 
252
  if (query == NULL)
 
253
  {
 
254
    return drizzle_query_options_t();
 
255
  }
 
256
 
189
257
  return drizzle_query_options_t(query->options);
190
258
}
191
259
 
192
260
void drizzle_query_set_options(drizzle_query_st *query,
193
261
                               drizzle_query_options_t options)
194
262
{
 
263
  if (query == NULL)
 
264
  {
 
265
    return;
 
266
  }
 
267
 
195
268
  query->options= options;
196
269
}
197
270
 
198
271
void drizzle_query_add_options(drizzle_query_st *query,
199
272
                               drizzle_query_options_t options)
200
273
{
 
274
  if (query == NULL)
 
275
  {
 
276
    return;
 
277
  }
 
278
 
201
279
  query->options|= options;
202
280
}
203
281
 
204
282
void drizzle_query_remove_options(drizzle_query_st *query,
205
283
                                  drizzle_query_options_t options)
206
284
{
 
285
  if (query == NULL)
 
286
  {
 
287
    return;
 
288
  }
 
289
 
207
290
  query->options&= ~options;
208
291
}
209
292
 
210
293
void *drizzle_query_context(drizzle_query_st *query)
211
294
{
 
295
  if (query == NULL)
 
296
  {
 
297
    return NULL;
 
298
  }
 
299
 
212
300
  return query->context;
213
301
}
214
302
 
215
303
void drizzle_query_set_context(drizzle_query_st *query, void *context)
216
304
{
 
305
  if (query == NULL)
 
306
  {
 
307
    return;
 
308
  }
 
309
 
217
310
  query->context= context;
218
311
}
219
312
 
220
313
void drizzle_query_set_context_free_fn(drizzle_query_st *query,
221
314
                                       drizzle_query_context_free_fn *function)
222
315
{
 
316
  if (query == NULL)
 
317
  {
 
318
    return;
 
319
  }
 
320
 
223
321
  query->context_free_fn= function;
224
322
}
225
323
 
226
324
static void drizzle_query_run_state(drizzle_query_st* query,
227
325
                                    drizzle_return_t* ret_ptr)
228
326
{
 
327
  drizzle_return_t unused_ret;
 
328
  if (ret_ptr == NULL)
 
329
  {
 
330
    ret_ptr= &unused_ret;
 
331
  }
 
332
 
 
333
  if (query == NULL)
 
334
  {
 
335
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
336
    return;
 
337
  }
 
338
 
229
339
  switch (query->state)
230
340
  {
231
341
  case DRIZZLE_QUERY_STATE_INIT:
264
374
drizzle_query_st *drizzle_query_run(drizzle_st *drizzle,
265
375
                                    drizzle_return_t *ret_ptr)
266
376
{
 
377
  drizzle_return_t unused_ret;
 
378
  if (ret_ptr == NULL)
 
379
  {
 
380
    ret_ptr= &unused_ret;
 
381
  }
 
382
 
 
383
  if (drizzle == NULL)
 
384
  {
 
385
    *ret_ptr= DRIZZLE_RETURN_INVALID_ARGUMENT;
 
386
    return NULL;
 
387
  }
 
388
 
267
389
  int options;
268
390
  drizzle_query_st *query;
269
391
  drizzle_con_st *con;
341
463
 
342
464
drizzle_return_t drizzle_query_run_all(drizzle_st *drizzle)
343
465
{
344
 
  drizzle_return_t ret;
 
466
  if (drizzle == NULL)
 
467
  {
 
468
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
469
  }
345
470
 
346
471
  while (drizzle->query_new > 0 || drizzle->query_running > 0)
347
472
  {
 
473
    drizzle_return_t ret;
 
474
 
348
475
    (void)drizzle_query_run(drizzle, &ret);
349
476
    if (ret != DRIZZLE_RETURN_OK && ret != DRIZZLE_RETURN_ERROR_CODE)
350
477
      return ret;
355
482
 
356
483
ssize_t drizzle_safe_escape_string(char *to, size_t max_to_size, const char *from, size_t from_size)
357
484
{
 
485
  if (to == NULL or max_to_size == 0 or from == NULL or from_size == 0)
 
486
  {
 
487
    return -1;
 
488
  }
 
489
 
358
490
  ssize_t to_size= 0;
359
491
  char newchar;
360
492
  const char *end;
423
555
 
424
556
size_t drizzle_hex_string(char *to, const char *from, size_t from_size)
425
557
{
 
558
  if (to == NULL or from == NULL or from_size == 0)
 
559
  {
 
560
    return size_t(-1);
 
561
  }
 
562
 
426
563
  static const char hex_map[]= "0123456789ABCDEF";
427
564
  const char *from_end;
428
565