← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/conn.cc

  • Committer: Brian Aker
  • Date: 2011-11-26 23:14:59 UTC
  • mto: This revision was merged to the branch mainline in revision 2465.
  • Revision ID: brian@tangent.org-20111126231459-pa9i3arizevf0vlr
Remove con from being passed object.

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