← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/conn.cc

  • Committer: Mark Atwood
  • Date: 2011-11-22 17:04:41 UTC
  • mfrom: (2462.1.3 drizzle-include)
  • Revision ID: me@mark.atwood.name-20111122170441-5dehm0e0ax20z19b
merge lp:~brianaker/drizzle/fedora-16-fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/conn.cc
176
176
  return con->options;
177
177
}
178
178
 
179
 
void drizzle_con_set_options(drizzle_con_st *con, int options)
 
179
void drizzle_con_set_options(drizzle_con_st *con,
 
180
                             int options)
180
181
{
181
182
  con->options= options;
182
183
}
183
184
 
184
 
void drizzle_con_add_options(drizzle_con_st *con, int options)
 
185
void drizzle_con_add_options(drizzle_con_st *con,
 
186
                             int options)
185
187
{
186
188
  con->options|= options;
187
189
 
188
190
  /* If asking for the experimental Drizzle protocol, clean the MySQL flag. */
189
191
  if (con->options & DRIZZLE_CON_EXPERIMENTAL)
190
 
  {
191
192
    con->options&= ~DRIZZLE_CON_MYSQL;
192
 
  }
193
193
}
194
194
 
195
 
void drizzle_con_remove_options(drizzle_con_st *con, int options)
 
195
void drizzle_con_remove_options(drizzle_con_st *con,
 
196
                                int options)
196
197
{
197
198
  con->options&= ~options;
198
199
}
199
200
 
200
201
const char *drizzle_con_host(const drizzle_con_st *con)
201
202
{
202
 
  if (con == NULL)
203
 
  {
204
 
    return NULL;
205
 
  }
206
 
 
207
203
  if (con->socket_type == DRIZZLE_CON_SOCKET_TCP)
208
204
  {
209
205
    if (con->socket.tcp.host == NULL && !(con->options & DRIZZLE_CON_LISTEN))
210
 
    {
211
206
      return DRIZZLE_DEFAULT_TCP_HOST;
212
 
    }
213
207
 
214
208
    return con->socket.tcp.host;
215
209
  }
240
234
  con->socket_type= DRIZZLE_CON_SOCKET_TCP;
241
235
 
242
236
  if (host == NULL)
243
 
  {
244
237
    con->socket.tcp.host= NULL;
245
 
  }
246
238
  else
247
239
  {
248
240
    con->socket.tcp.host= con->socket.tcp.host_buffer;
255
247
 
256
248
const char *drizzle_con_user(const drizzle_con_st *con)
257
249
{
258
 
  if (con == NULL)
259
 
  {
260
 
    return NULL;
261
 
  }
262
 
 
263
250
  return con->user;
264
251
}
265
252
 
266
253
const char *drizzle_con_password(const drizzle_con_st *con)
267
254
{
268
 
  if (con == NULL)
269
 
  {
270
 
    return NULL;
271
 
  }
272
 
 
273
255
  return con->password;
274
256
}
275
257
 
276
 
void drizzle_con_set_auth(drizzle_con_st *con, const char *user, const char *password)
 
258
void drizzle_con_set_auth(drizzle_con_st *con, const char *user,
 
259
                          const char *password)
277
260
{
278
 
  if (con == NULL)
279
 
  {
280
 
    return;
281
 
  }
282
 
 
283
261
  if (user == NULL)
284
 
  {
285
262
    con->user[0]= 0;
286
 
  }
287
263
  else
288
264
  {
289
265
    strncpy(con->user, user, DRIZZLE_MAX_USER_SIZE);
392
368
 
393
369
uint32_t drizzle_con_server_version_number(const drizzle_con_st *con)
394
370
{
395
 
  if (con == NULL or con->server_version)
 
371
  if (con == NULL)
396
372
  {
397
373
    return 0;
398
374
  }
638
614
        }
639
615
      }
640
616
 
641
 
      con->result= drizzle_result_create_with(con, result);
 
617
      con->result= drizzle_result_create(con, result);
642
618
      if (con->result == NULL)
643
619
      {
644
620
        *ret_ptr= DRIZZLE_RETURN_MEMORY;
1068
1044
 
1069
1045
drizzle_return_t drizzle_state_connect(drizzle_con_st *con)
1070
1046
{
1071
 
  if (con == NULL)
1072
 
  {
1073
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1074
 
  }
1075
1047
  drizzle_log_debug(con->drizzle, "drizzle_state_connect");
1076
1048
 
1077
1049
  if (con->fd != -1)
1180
1152
 
1181
1153
drizzle_return_t drizzle_state_connecting(drizzle_con_st *con)
1182
1154
{
1183
 
  if (con == NULL)
1184
 
  {
1185
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1186
 
  }
1187
1155
  drizzle_log_debug(con->drizzle, "drizzle_state_connecting");
1188
1156
 
1189
1157
  while (1)
1221
1189
 
1222
1190
drizzle_return_t drizzle_state_read(drizzle_con_st *con)
1223
1191
{
1224
 
  if (con == NULL)
1225
 
  {
1226
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1227
 
  }
 
1192
  drizzle_return_t ret;
1228
1193
 
1229
1194
  drizzle_log_debug(con->drizzle, "drizzle_state_read");
1230
1195
 
1242
1207
    /* non-blocking mode: return IO_WAIT instead of attempting to read. This
1243
1208
     * avoids reading immediately after writing a command, which typically
1244
1209
     * returns EAGAIN. This improves performance. */
1245
 
    drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
1210
    ret= drizzle_con_set_events(con, POLLIN);
1246
1211
    if (ret != DRIZZLE_RETURN_OK)
1247
 
    {
1248
1212
      return ret;
1249
 
    }
1250
1213
    return DRIZZLE_RETURN_IO_WAIT;
1251
1214
  }
1252
1215
 
1308
1271
      {
1309
1272
        /* clear the read ready flag */
1310
1273
        con->revents&= ~POLLIN;
1311
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLIN);
 
1274
        ret= drizzle_con_set_events(con, POLLIN);
1312
1275
        if (ret != DRIZZLE_RETURN_OK)
1313
 
        {
1314
1276
          return ret;
1315
 
        }
1316
1277
 
1317
1278
        if (con->drizzle->options.is_non_blocking)
1318
1279
        {
1361
1322
 
1362
1323
drizzle_return_t drizzle_state_write(drizzle_con_st *con)
1363
1324
{
1364
 
  if (con == NULL)
1365
 
  {
1366
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1367
 
  }
 
1325
  drizzle_return_t ret;
1368
1326
 
1369
1327
  drizzle_log_debug(con->drizzle, "drizzle_state_write");
1370
1328
 
1422
1380
    {
1423
1381
      if (errno == EAGAIN)
1424
1382
      {
1425
 
        drizzle_return_t ret= drizzle_con_set_events(con, POLLOUT);
 
1383
        ret= drizzle_con_set_events(con, POLLOUT);
1426
1384
        if (ret != DRIZZLE_RETURN_OK)
1427
1385
        {
1428
1386
          return ret;
1478
1436
  int opt;
1479
1437
  drizzle_con_st *new_con;
1480
1438
 
1481
 
  if (con == NULL)
1482
 
  {
1483
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1484
 
  }
1485
 
 
1486
 
 
1487
1439
  for (; con->addrinfo_next != NULL;
1488
1440
       con->addrinfo_next= con->addrinfo_next->ai_next)
1489
1441
  {
1556
1508
    }
1557
1509
    else
1558
1510
    {
1559
 
      new_con= drizzle_con_clone(con->drizzle, con);
 
1511
      new_con= drizzle_con_clone(con->drizzle, NULL, con);
1560
1512
      if (new_con == NULL)
1561
1513
      {
1562
1514
        closesocket(fd);
1579
1531
 
1580
1532
  /* Report last socket() error if we couldn't find an address to bind. */
1581
1533
  if (con->fd == -1)
1582
 
  {
1583
1534
    return DRIZZLE_RETURN_ERRNO;
1584
 
  }
1585
1535
 
1586
1536
  drizzle_state_pop(con);
1587
1537
  return DRIZZLE_RETURN_OK;
1597
1547
  struct linger linger;
1598
1548
  struct timeval waittime;
1599
1549
 
1600
 
  if (con == NULL)
1601
 
  {
1602
 
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
1603
 
  }
1604
 
 
1605
 
 
1606
1550
  ret= 1;
1607
1551
 
1608
1552
#ifdef _WIN32