← Back to branch summary

~drizzle-trunk/libdrizzle/jenkins-Libdrizzle-29

« back to all changes in this revision

Viewing changes to libdrizzle/drizzle.cc

  • Committer: Andrew Hutchings
  • Date: 2012-12-22 08:55:58 UTC
  • mfrom: (43.2.18 5.0)
  • Revision ID: andrew@linuxjedi.co.uk-20121222085558-b3aj47q2ah3cfccg
Merge 5.0 into 5.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/drizzle.cc
112
112
  return _verbose_name[verbose];
113
113
}
114
114
 
115
 
int drizzle_con_timeout(const drizzle_con_st *con)
 
115
int drizzle_timeout(const drizzle_st *con)
116
116
{
117
117
  if (con == NULL)
118
118
  {
122
122
  return con->timeout;
123
123
}
124
124
 
125
 
void drizzle_con_set_timeout(drizzle_con_st *con, int timeout)
 
125
void drizzle_set_timeout(drizzle_st *con, int timeout)
126
126
{
127
127
  if (con == NULL)
128
128
  {
132
132
  con->timeout= timeout;
133
133
}
134
134
 
135
 
drizzle_verbose_t drizzle_con_verbose(const drizzle_con_st *con)
 
135
drizzle_verbose_t drizzle_verbose(const drizzle_st *con)
136
136
{
137
137
  if (con == NULL)
138
138
  {
142
142
  return con->verbose;
143
143
}
144
144
 
145
 
void drizzle_con_set_verbose(drizzle_con_st *con, drizzle_verbose_t verbose)
 
145
void drizzle_set_verbose(drizzle_st *con, drizzle_verbose_t verbose)
146
146
{
147
147
  if (con == NULL)
148
148
  {
152
152
  con->verbose= verbose;
153
153
}
154
154
 
155
 
void drizzle_con_set_log_fn(drizzle_con_st *con, drizzle_log_fn *function,
 
155
void drizzle_set_log_fn(drizzle_st *con, drizzle_log_fn *function,
156
156
                            void *context)
157
157
{
158
158
  if (con == NULL)
164
164
  con->log_context= context;
165
165
}
166
166
 
167
 
drizzle_con_st *drizzle_con_create(void)
 
167
drizzle_st *drizzle_create(void)
168
168
{
169
 
  drizzle_con_st *con;
 
169
  drizzle_st *con;
170
170
 
171
 
  con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
 
171
  con= (drizzle_st*)malloc(sizeof(drizzle_st));
172
172
  if (con == NULL)
173
173
  {
174
174
    return NULL;
228
228
  return con;
229
229
}
230
230
 
231
 
void drizzle_con_free(drizzle_con_st *con)
 
231
void drizzle_free(drizzle_st *con)
232
232
{
233
233
  if (con == NULL)
234
234
  {
244
244
 
245
245
  if (con->fd != -1)
246
246
  {
247
 
    drizzle_con_close(con);
 
247
    drizzle_close(con);
248
248
  }
249
249
 
250
 
  drizzle_con_reset_addrinfo(con);
 
250
  drizzle_reset_addrinfo(con);
251
251
 
252
252
#ifdef USE_OPENSSL
253
253
  if (con->ssl)
260
260
  free(con);
261
261
}
262
262
 
263
 
drizzle_return_t drizzle_con_wait(drizzle_con_st *con)
 
263
drizzle_return_t drizzle_wait(drizzle_st *con)
264
264
{
265
265
  if (con == NULL)
266
266
  {
275
275
  }
276
276
  else
277
277
  {
278
 
    drizzle_con_set_error(con, __func__, "no active file descriptors");
 
278
    drizzle_set_error(con, __func__, "no active file descriptors");
279
279
    return DRIZZLE_RETURN_NO_ACTIVE_CONNECTIONS;
280
280
  }
281
281
 
295
295
        continue;
296
296
      }
297
297
 
298
 
      drizzle_con_set_error(con, "drizzle_con_wait", "poll:%d", errno);
 
298
      drizzle_set_error(con, "drizzle_wait", "poll:%d", errno);
299
299
      con->last_errno= errno;
300
300
      return DRIZZLE_RETURN_ERRNO;
301
301
    }
305
305
 
306
306
  if (ret == 0)
307
307
  {
308
 
    drizzle_con_set_error(con, "drizzle_con_wait", "timeout reached");
 
308
    drizzle_set_error(con, "drizzle_wait", "timeout reached");
309
309
    return DRIZZLE_RETURN_TIMEOUT;
310
310
  }
311
311
 
312
 
  return drizzle_con_set_revents(con, con->pfds[0].revents);
 
312
  return drizzle_set_revents(con, con->pfds[0].revents);
313
313
}
314
314
 
315
 
drizzle_con_st *drizzle_con_ready(drizzle_con_st *con)
 
315
drizzle_st *drizzle_ready(drizzle_st *con)
316
316
{
317
317
  /* We can't keep state between calls since connections may be removed during
318
318
     processing. If this list ever gets big, we may want something faster. */
319
319
 
320
320
  if (con->options & DRIZZLE_CON_IO_READY)
321
321
  {
322
 
    con->options = (drizzle_con_options_t)((int)con->options & (int)~DRIZZLE_CON_IO_READY);
 
322
    con->options = (drizzle_options_t)((int)con->options & (int)~DRIZZLE_CON_IO_READY);
323
323
    return con;
324
324
  }
325
325
 
330
330
 * Client Definitions
331
331
 */
332
332
 
333
 
drizzle_con_st *drizzle_con_create_tcp(const char *host, in_port_t port,
 
333
drizzle_st *drizzle_create_tcp(const char *host, in_port_t port,
334
334
                                       const char *user, const char *password,
335
335
                                       const char *db,
336
 
                                       drizzle_con_options_t options)
 
336
                                       drizzle_options_t options)
337
337
{
338
 
  drizzle_con_st *con;
 
338
  drizzle_st *con;
339
339
 
340
 
  con= drizzle_con_create();
 
340
  con= drizzle_create();
341
341
  if (con == NULL)
342
342
  {
343
343
    return NULL;
344
344
  }
345
345
 
346
 
  drizzle_con_set_tcp(con, host, port);
347
 
  drizzle_con_set_auth(con, user, password);
348
 
  drizzle_con_set_db(con, db);
349
 
  drizzle_con_add_options(con, options);
 
346
  drizzle_set_tcp(con, host, port);
 
347
  drizzle_set_auth(con, user, password);
 
348
  drizzle_set_db(con, db);
 
349
  drizzle_add_options(con, options);
350
350
 
351
351
  return con;
352
352
}
353
353
 
354
 
drizzle_con_st *drizzle_con_create_uds(const char *uds, const char *user,
 
354
drizzle_st *drizzle_create_uds(const char *uds, const char *user,
355
355
                                    const char *password, const char *db,
356
 
                                    drizzle_con_options_t options)
 
356
                                    drizzle_options_t options)
357
357
{
358
 
  drizzle_con_st *con;
 
358
  drizzle_st *con;
359
359
 
360
 
  con= drizzle_con_create();
 
360
  con= drizzle_create();
361
361
  if (con == NULL)
362
362
  {
363
363
    return NULL;
364
364
  }
365
365
 
366
 
  drizzle_con_set_uds(con, uds);
367
 
  drizzle_con_set_auth(con, user, password);
368
 
  drizzle_con_set_db(con, db);
369
 
  drizzle_con_add_options(con, options);
 
366
  drizzle_set_uds(con, uds);
 
367
  drizzle_set_auth(con, user, password);
 
368
  drizzle_set_db(con, db);
 
369
  drizzle_add_options(con, options);
370
370
 
371
371
  return con;
372
372
}
375
375
 * Local Definitions
376
376
 */
377
377
 
378
 
void drizzle_con_set_error(drizzle_con_st *con, const char *function,
 
378
void drizzle_set_error(drizzle_st *con, const char *function,
379
379
                           const char *format, ...)
380
380
{
381
381
  if (con == NULL)
424
424
  }
425
425
}
426
426
 
427
 
void drizzle_con_log(drizzle_con_st *con, drizzle_verbose_t verbose,
 
427
void drizzle_log(drizzle_st *con, drizzle_verbose_t verbose,
428
428
                 const char *format, va_list args)
429
429
{
430
430
  if (con == NULL)