~drizzle-trunk/drizzle/development

N_("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter."))

1302

("no-beep,b", po::value<bool>(&opt_nobeep)->default_value(false)->zero_tokens(),

1303

N_("Turn off beep on error."))

1304

("disable-line-numbers", N_("Do not write line numbers for errors."))

1305

("disable-column-names", N_("Do not write column names in results."))

1306

("skip-column-names,N",

1307

N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))

1308

("set-variable,O", po::value<string>(),

1309

N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))

1310

("table,t", po::value<bool>(&output_tables)->default_value(false)->zero_tokens(),

1311

N_("Output in table format."))

1312

("safe-updates,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),

1313

N_("Only allow UPDATE and DELETE that uses keys."))

1314

("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),

1315

N_("Synonym for option --safe-updates, -U."))

1316

("verbose,v", po::value<string>(&opt_verbose)->default_value(""),

1317

N_("-v vvv implies that verbose= 3, Used to specify verbose"))

1318

("version,V", N_("Output version information and exit."))

1319

("secure-auth", po::value<bool>(&opt_secure_auth)->default_value(false)->zero_tokens(),

1320

N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))

1321

("show-warnings", po::value<bool>(&show_warnings)->default_value(false)->zero_tokens(),

1322

N_("Show warnings after every statement."))

1323

("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(0),

1324

N_("Number of lines before each import progress report."))

1325

("ping", po::value<bool>(&opt_ping)->default_value(false)->zero_tokens(),

1326

N_("Ping the server to check if it's alive."))

1327

("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),

1328

N_("Configuration file defaults are not used if no-defaults is set"))

1329

;

1330

1331

po::options_description drizzle_options(N_("Options specific to the drizzle client"));

1332

drizzle_options.add_options()

1333

("disable-auto-rehash,A",

1334

N_("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))

1335

("auto-vertical-output", po::value<bool>(&auto_vertical_output)->default_value(false)->zero_tokens(),

1336

N_("Automatically switch to vertical output mode if the result is wider than the terminal width."))

1337

("database,D", po::value<string>(&current_db)->default_value(""),

1338

N_("Database to use."))

1339

("default-character-set",po::value<string>(),

1340

N_("(not used)"))

1341

("delimiter", po::value<string>(&delimiter_str)->default_value(";"),

1342

N_("Delimiter to be used."))

1343

("execute,e", po::value<string>(),

1344

N_("Execute command and quit. (Disables --force and history file)"))

1345

("local-infile", po::value<bool>(&opt_local_infile)->default_value(false)->zero_tokens(),

1346

N_("Enable LOAD DATA LOCAL INFILE."))

1347

("unbuffered,n", po::value<bool>(&unbuffered)->default_value(false)->zero_tokens(),

1348

N_("Flush buffer after each query."))

1349

("sigint-ignore", po::value<bool>(&opt_sigint_ignore)->default_value(false)->zero_tokens(),

1350

N_("Ignore SIGINT (CTRL-C)"))

1351

("one-database,o", po::value<bool>(&one_database)->default_value(false)->zero_tokens(),

1352

N_("Only update the default database. This is useful for skipping updates to other database in the update log."))

1353

("pager", po::value<string>(),

1354

N_("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."))

1355

("disable-pager", po::value<bool>(&opt_nopager)->default_value(false)->zero_tokens(),

1356

N_("Disable pager and print to stdout. See interactive help (\\h) also."))

1357

("prompt", po::value<string>(&current_prompt)->default_value(""),

1358

N_("Set the drizzle prompt to this value."))

1359

("quick,q", po::value<bool>(&quick)->default_value(false)->zero_tokens(),

1360

N_("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."))

1361

("raw,r", po::value<bool>(&opt_raw_data)->default_value(false)->zero_tokens(),

1362

N_("Write fields without conversion. Used with --batch."))

1363

("disable-reconnect", N_("Do not reconnect if the connection is lost."))

1364

("shutdown", po::value<bool>()->zero_tokens(),

1365

N_("Shutdown the server"))

1366

("silent,s", N_("Be more silent. Print results with a tab as separator, each row on new line."))

1367

("tee", po::value<string>(),

1368

N_("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."))

1369

("disable-tee", po::value<bool>()->default_value(false)->zero_tokens(),

1370

N_("Disable outfile. See interactive help (\\h) also."))

1371

("connect-timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),

1372

N_("Number of seconds before connection timeout."))

1373

("max-input-line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),

1374

N_("Max length of input line"))

1375

("select-limit", po::value<uint32_t>(&select_limit)->default_value(1000L),

1376

N_("Automatic limit for SELECT when using --safe-updates"))

1377

("max-join-size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),

1378

N_("Automatic limit for rows in a join when using --safe-updates"))

1379

;

1380

1381

po::options_description client_options(N_("Options specific to the client"));

1382

client_options.add_options()

1383

("host,h", po::value<string>(&current_host)->default_value("localhost"),

1384

N_("Connect to host"))

1385

("password,P", po::value<string>(&current_password)->default_value(PASSWORD_SENTINEL),

1386

N_("Password to use when connecting to server. If password is not given it's asked from the tty."))

1387

("port,p", po::value<uint32_t>()->default_value(0),

1388

N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))

1389

#ifdef DRIZZLE_ADMIN_TOOL

1390

("user,u", po::value<string>(&current_user)->default_value("root"),

1391

#else

1392

("user,u", po::value<string>(&current_user)->default_value(""),

1393

#endif

1394

N_("User for login if not current user."))

1395

("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),

1396

N_("The protocol of connection (mysql or drizzle)."))

1397

;

1398

1399

po::options_description long_options(N_("Allowed Options"));

1400

long_options.add(commandline_options).add(drizzle_options).add(client_options);

1401

1402

std::string system_config_dir_drizzle(SYSCONFDIR);

1403

system_config_dir_drizzle.append("/drizzle/drizzle.cnf");

1404

1405

std::string system_config_dir_client(SYSCONFDIR);

1406

system_config_dir_client.append("/drizzle/client.cnf");

1407

1408

std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));

1409

1410

if (user_config_dir.compare(0, 2, "~/") == 0)

1411

{

1412

char *homedir;

1413

homedir= getenv("HOME");

1414

if (homedir != NULL)

1415

user_config_dir.replace(0, 1, homedir);

1416

}

1417

1418

po::variables_map vm;

1419

1420

po::positional_options_description p;

1421

p.add("database", 1);

1422

1423

// Disable allow_guessing

1424

int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

1425

1426

po::store(po::command_line_parser(argc, argv).options(long_options).

1427

style(style).positional(p).extra_parser(parse_password_arg).run(),

1428

vm);

1429

1430

if (! vm["no-defaults"].as<bool>())

1431

{

1432

std::string user_config_dir_drizzle(user_config_dir);

1433

user_config_dir_drizzle.append("/drizzle/drizzle.cnf");

1434

1435

std::string user_config_dir_client(user_config_dir);

1436

user_config_dir_client.append("/drizzle/client.cnf");

1437

1438

ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());

1439

po::store(dpo::parse_config_file(user_drizzle_ifs, drizzle_options), vm);

1440

1441

ifstream user_client_ifs(user_config_dir_client.c_str());

1442

po::store(dpo::parse_config_file(user_client_ifs, client_options), vm);

1443

1444

ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());

1445

store(dpo::parse_config_file(system_drizzle_ifs, drizzle_options), vm);

1446

1447

ifstream system_client_ifs(system_config_dir_client.c_str());

1448

po::store(dpo::parse_config_file(system_client_ifs, client_options), vm);

1449

}

1450

1451

po::notify(vm);

1452

1453

#ifdef DRIZZLE_ADMIN_TOOL

1454

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1455

getenv("DRIZZLE_PS1") :

1456

"drizzleadmin> ");

1457

#else

1165

MY_INIT(argv[0]);

1166

delimiter_str= delimiter;

1458

1167

default_prompt= strdup(getenv("DRIZZLE_PS1") ?

1459

1168

getenv("DRIZZLE_PS1") :

1460

1169

"drizzle> ");

1461

#endif

1170

1462

1171

if (default_prompt == NULL)

1463

1172

{

1464

1173

fprintf(stderr, _("Memory allocation error while constructing initial "

1466

1175

exit(ENOMEM);

1467

1176

}

1468

1177

current_prompt= strdup(default_prompt);

1469

if (current_prompt.empty())

1178

if (current_prompt == NULL)

1470

1179

{

1471

1180

fprintf(stderr, _("Memory allocation error while constructing initial "

1472

1181

"prompt. Aborting.\n"));

1477

1186

1478

1187

prompt_counter=0;

1479

1188

1480

outfile.clear(); // no (default) outfile

1481

pager.assign("stdout"); // the default, if --pager wasn't given

1189

outfile[0]=0; // no (default) outfile

1190

strcpy(pager, "stdout"); // the default, if --pager wasn't given

1482

1191

{

1483

const char *tmp= getenv("PAGER");

1192

char *tmp=getenv("PAGER");

1484

1193

if (tmp && strlen(tmp))

1485

1194

{

1486

1195

default_pager_set= 1;

1487

default_pager.assign(tmp);

1196

strcpy(default_pager, tmp);

1488

1197

}

1489

1198

}

1490

if (! isatty(0) || ! isatty(1))

1199

if (!isatty(0) || !isatty(1))

1491

1200

{

1492

status.setBatch(1); opt_silent=1;

1201

status.batch=1; opt_silent=1;

1493

1202

ignore_errors=0;

1494

1203

}

1495

1204

else

1496

status.setAddToHistory(1);

1497

status.setExitStatus(1);

1205

status.add_to_history=1;

1206

status.exit_status=1;

1498

1207

1499

1208

{

1500

1209

1510

1219

close(stdout_fileno_copy); /* Clean up dup(). */

1511

1220

}

1512

1221

1513

/* Inverted Booleans */

1514

1515

line_numbers= (vm.count("disable-line-numbers")) ? false : true;

1516

column_names= (vm.count("disable-column-names")) ? false : true;

1517

opt_rehash= (vm.count("disable-auto-rehash")) ? false : true;

1518

opt_reconnect= (vm.count("disable-reconnect")) ? false : true;

1519

1520

/* Don't rehash with --shutdown */

1521

if (vm.count("shutdown"))

1522

{

1523

opt_rehash= false;

1524

opt_shutdown= true;

1525

}

1526

1527

if (vm.count("delimiter"))

1528

{

1529

/* Check that delimiter does not contain a backslash */

1530

if (! strstr(delimiter_str.c_str(), "\\"))

1531

{

1532

delimiter= (char *)delimiter_str.c_str();

1533

}

1534

else

1535

{

1536

put_info(_("DELIMITER cannot contain a backslash character"),

1537

INFO_ERROR,0,0);

1538

exit(-1);

1539

}

1540

1541

delimiter_length= (uint32_t)strlen(delimiter);

1542

}

1543

if (vm.count("tee"))

1544

{

1545

if (vm["tee"].as<string>().empty())

1546

{

1547

if (opt_outfile)

1548

end_tee();

1549

}

1550

else

1551

init_tee(vm["tee"].as<string>().c_str());

1552

}

1553

if (vm["disable-tee"].as<bool>() == true)

1554

{

1555

if (opt_outfile)

1556

end_tee();

1557

}

1558

if (vm.count("pager"))

1559

{

1560

if (vm["pager"].as<string>().empty())

1561

opt_nopager= 1;

1562

else

1563

{

1564

opt_nopager= 0;

1565

if (vm[pager].as<string>().length())

1566

{

1567

default_pager_set= 1;

1568

pager.assign(vm["pager"].as<string>());

1569

default_pager.assign(pager);

1570

}

1571

else if (default_pager_set)

1572

pager.assign(default_pager);

1573

else

1574

opt_nopager= 1;

1575

}

1576

}

1577

if (vm.count("disable-pager"))

1578

{

1579

opt_nopager= 1;

1580

}

1581

1582

if (vm.count("no-auto-rehash"))

1583

opt_rehash= 0;

1584

1585

if (vm.count("skip-column-names"))

1586

column_names= 0;

1587

1588

if (vm.count("execute"))

1589

{

1590

status.setBatch(1);

1591

status.setAddToHistory(1);

1592

if (status.getLineBuff() == NULL)

1593

status.setLineBuff(opt_max_input_line,NULL);

1594

if (status.getLineBuff() == NULL)

1595

{

1596

exit(1);

1597

}

1598

status.getLineBuff()->addString(vm["execute"].as<string>().c_str());

1599

}

1600

1601

if (one_database)

1602

skip_updates= true;

1603

1604

if (vm.count("protocol"))

1605

{

1606

std::transform(opt_protocol.begin(), opt_protocol.end(),

1607

opt_protocol.begin(), ::tolower);

1608

1609

if (not opt_protocol.compare("mysql"))

1610

use_drizzle_protocol=false;

1611

else if (not opt_protocol.compare("drizzle"))

1612

use_drizzle_protocol=true;

1613

else

1614

{

1615

cout << _("Error: Unknown protocol") << " '" << opt_protocol << "'" << endl;

1616

exit(-1);

1617

}

1618

}

1619

1620

if (vm.count("port"))

1621

{

1622

opt_drizzle_port= vm["port"].as<uint32_t>();

1623

1624

/* If the port number is > 65535 it is not a valid port

1625

This also helps with potential data loss casting unsigned long to a

1626

uint32_t. */

1627

if (opt_drizzle_port > 65535)

1628

{

1629

printf(_("Error: Value of %" PRIu32 " supplied for port is not valid.\n"), opt_drizzle_port);

1630

exit(-1);

1631

}

1632

}

1633

1634

if (vm.count("password"))

1635

{

1636

if (!opt_password.empty())

1637

opt_password.erase();

1638

if (current_password == PASSWORD_SENTINEL)

1639

{

1640

opt_password= "";

1641

}

1642

else

1643

{

1644

opt_password= current_password;

1645

tty_password= false;

1646

}

1647

}

1648

else

1649

{

1650

tty_password= true;

1651

}

1652

1653

1654

if (!opt_verbose.empty())

1655

{

1656

verbose= opt_verbose.length();

1657

}

1658

1659

if (vm.count("batch"))

1660

{

1661

status.setBatch(1);

1662

status.setAddToHistory(0);

1663

if (opt_silent < 1)

1664

{

1665

opt_silent= 1;

1666

}

1667

}

1668

if (vm.count("silent"))

1669

{

1670

opt_silent++;

1671

}

1672

1673

if (vm.count("help") || vm.count("version"))

1674

{

1675

printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),

1676

drizzle_version(), VERSION,

1677

HOST_VENDOR, HOST_OS, HOST_CPU,

1678

rl_library_version);

1679

if (vm.count("version"))

1680

exit(0);

1681

1682

"This software comes with ABSOLUTELY NO WARRANTY. "

1683

"This is free software,\n"

1684

"and you are welcome to modify and redistribute it "

1685

"under the GPL license\n"));

1686

printf(_("Usage: drizzle [OPTIONS] [database]\n"));

1687

cout << long_options;

1688

exit(0);

1689

}

1690

1691

1692

if (process_options())

1693

{

1222

load_defaults("drizzle",load_default_groups,&argc,&argv);

1223

defaults_argv=argv;

1224

if (get_options(argc, (char **) argv))

1225

{

1226

free_defaults(defaults_argv);

1227

my_end(0);

1694

1228

exit(1);

1695

1229

}

1696

1230

1697

1231

memset(&drizzle, 0, sizeof(drizzle));

1698

if (sql_connect(current_host, current_db, current_user, opt_password,opt_silent))

1232

if (sql_connect(current_host,current_db,current_user,opt_password,

1233

opt_silent))

1699

1234

{

1700

1235

quick= 1; // Avoid history

1701

status.setExitStatus(1);

1236

status.exit_status= 1;

1702

1237

drizzle_end(-1);

1703

1238

}

1704

1239

1706

1241

if (execute_commands(&command_error) != false)

1707

1242

{

1708

1243

/* we've executed a command so exit before we go into readline mode */

1244

free_defaults(defaults_argv);

1245

my_end(0);

1709

1246

exit(command_error);

1710

1247

}

1711

1248

1712

if (status.getBatch() && !status.getLineBuff())

1249

if (status.batch && !status.line_buff)

1713

1250

{

1714

status.setLineBuff(opt_max_input_line, stdin);

1715

if (status.getLineBuff() == NULL)

1251

status.line_buff= new(std::nothrow) LineBuffer(opt_max_input_line, stdin);

1252

if (status.line_buff == NULL)

1716

1253

{

1254

free_defaults(defaults_argv);

1255

my_end(0);

1717

1256

exit(1);

1718

1257

}

1719

1258

}

1720

1259

1721

if (!status.getBatch())

1260

if (!status.batch)

1722

1261

ignore_errors=1; // Don't abort monitor

1723

1262

1724

1263

if (opt_sigint_ignore)

1733

1272

/* call the SIGWINCH handler to get the default term width */

1734

1273

window_resize(0);

1735

1274

#endif

1736

std::vector<char> output_buff;

1737

output_buff.resize(512);

1738

1739

snprintf(&output_buff[0], output_buff.size(),

1740

_("Welcome to the Drizzle client.. Commands end with %s or \\g."),

1741

delimiter);

1742

1743

put_info(&output_buff[0], INFO_INFO, 0, 0);

1275

1276

put_info(_("Welcome to the Drizzle client.. Commands end with ; or \\g."),

1277

INFO_INFO,0,0);

1744

1278

1745

1279

glob_buffer= new string();

1746

1280

glob_buffer->reserve(512);

1747

1281

1748

snprintf(&output_buff[0], output_buff.size(),

1749

_("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),

1282

char * output_buff= (char *)malloc(512);

1283

memset(output_buff, '\0', 512);

1284

1285

sprintf(output_buff,

1286

_("Your Drizzle connection id is %u\nServer version: %s\n"),

1750

1287

drizzle_con_thread_id(&con),

1751

opt_protocol.c_str(),

1752

1288

server_version_string(&con));

1753

put_info(&output_buff[0], INFO_INFO, 0, 0);

1754

1755

1756

initialize_readline((char *)current_prompt.c_str());

1757

if (!status.getBatch() && !quick)

1289

put_info(output_buff, INFO_INFO, 0, 0);

1290

1291

initialize_readline(current_prompt);

1292

if (!status.batch && !quick)

1758

1293

{

1759

1294

/* read-history from file, default ~/.drizzle_history*/

1760

1295

if (getenv("DRIZZLE_HISTFILE"))

1793

1328

1794

1329

put_info(_("Type 'help;' or '\\h' for help. "

1795

1330

"Type '\\c' to clear the buffer.\n"),INFO_INFO,0,0);

1796

status.setExitStatus(read_and_execute(!status.getBatch()));

1331

status.exit_status= read_and_execute(!status.batch);

1797

1332

if (opt_outfile)

1798

1333

end_tee();

1799

1334

drizzle_end(0);

1800

}

1801

1335

1802

catch(exception &err)

1803

{

1804

cerr << _("Error:") << err.what() << endl;

1805

}

1806

1336

return(0); // Keep compiler happy

1807

1337

}

1808

1338

1810

1340

{

1811

1341

drizzle_con_free(&con);

1812

1342

drizzle_free(&drizzle);

1813

if (!status.getBatch() && !quick && histfile)

1343

if (!status.batch && !quick && histfile)

1814

1344

{

1815

1345

/* write-history */

1816

1346

if (verbose)

1817

1347

tee_fprintf(stdout, _("Writing history-file %s\n"),histfile);

1818

1348

if (!write_history(histfile_tmp))

1819

rename(histfile_tmp, histfile);

1349

my_rename(histfile_tmp, histfile, MYF(MY_WME));

1820

1350

}

1821

delete status.getLineBuff();

1822

status.setLineBuff(0);

1351

delete status.line_buff;

1352

status.line_buff= 0;

1823

1353

1824

1354

if (sig >= 0)

1825

1355

put_info(sig ? _("Aborted") : _("Bye"), INFO_RESULT,0,0);

1826

delete glob_buffer;

1827

delete processed_prompt;

1828

opt_password.erase();

1356

if (glob_buffer)

1357

delete glob_buffer;

1358

if (processed_prompt)

1359

delete processed_prompt;

1360

free(opt_password);

1361

free(opt_drizzle_unix_port);

1829

1362

free(histfile);

1830

1363

free(histfile_tmp);

1831

current_db.erase();

1832

current_host.erase();

1833

current_user.erase();

1364

free(current_db);

1365

free(current_host);

1366

free(current_user);

1834

1367

free(full_username);

1835

1368

free(part_username);

1836

1369

free(default_prompt);

1837

current_prompt.erase();

1838

exit(status.getExitStatus());

1370

free(current_prompt);

1371

free_defaults(defaults_argv);

1372

my_end(my_end_arg);

1373

exit(status.exit_status);

1839

1374

}

1840

1375

1841

1376

1848

1383

void handle_sigint(int sig)

1849

1384

{

1850

1385

char kill_buffer[40];

1851

boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);

1386

drizzle_con_st kill_drizzle;

1852

1387

drizzle_result_st res;

1853

1388

drizzle_return_t ret;

1854

1389

1857

1392

goto err;

1858

1393

}

1859

1394

1860

if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),

1861

opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,

1862

use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)

1395

if (drizzle_con_add_tcp(&drizzle, &kill_drizzle, current_host,

1396

opt_drizzle_port, current_user, opt_password, NULL,

1397

DRIZZLE_CON_NONE) == NULL)

1863

1398

{

1864

1399

goto err;

1865

1400

}

1868

1403

sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",

1869

1404

drizzle_con_thread_id(&con));

1870

1405

1871

if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)

1406

if (drizzle_query_str(&kill_drizzle, &res, kill_buffer, &ret) != NULL)

1872

1407

drizzle_result_free(&res);

1873

1408

1874

drizzle_con_free(kill_drizzle.get());

1409

drizzle_con_free(&kill_drizzle);

1875

1410

tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));

1876

1411

1877

1412

interrupted_query= 1;

1893

1428

}

1894

1429

#endif

1895

1430

1896

1897

1898

static int process_options(void)

1431

static struct my_option my_long_options[] =

1432

{

1433

{"help", '?', N_("Display this help and exit."), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

1434

0, 0, 0, 0, 0},

1435

{"help", 'I', N_("Synonym for -?"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0,

1436

0, 0, 0, 0, 0},

1437

{"auto-rehash", OPT_AUTO_REHASH,

1438

N_("Enable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time. Disable with --disable-auto-rehash."),

1439

(char**) &opt_rehash, (char**) &opt_rehash, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0,

1440

0, 0},

1441

{"no-auto-rehash", 'A',

1442

N_("No automatic rehashing. One has to use 'rehash' to get table and field completion. This gives a quicker start of drizzle_st and disables rehashing on reconnect. WARNING: options deprecated; use --disable-auto-rehash instead."),

1443

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1444

{"auto-vertical-output", OPT_AUTO_VERTICAL_OUTPUT,

1445

N_("Automatically switch to vertical output mode if the result is wider than the terminal width."),

1446

(char**) &auto_vertical_output, (char**) &auto_vertical_output, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1447

{"batch", 'B',

1448

N_("Don't use history file. Disable interactive behavior. (Enables --silent)"), 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1449

{"column-type-info", OPT_COLUMN_TYPES, N_("Display column type information."),

1450

(char**) &column_types_flag, (char**) &column_types_flag,

1451

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1452

{"comments", 'c', N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"),

1453

(char**) &preserve_comments, (char**) &preserve_comments,

1454

0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1455

{"compress", 'C', N_("Use compression in server/client protocol."),

1456

(char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,

1457

0, 0, 0},

1458

{"debug-check", OPT_DEBUG_CHECK, N_("Check memory and open file usage at exit ."),

1459

(char**) &debug_check_flag, (char**) &debug_check_flag, 0,

1460

GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1461

{"debug-info", 'T', N_("Print some debug info at exit."), (char**) &debug_info_flag,

1462

(char**) &debug_info_flag, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1463

{"database", 'D', N_("Database to use."), (char**) &current_db,

1464

(char**) &current_db, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1465

{"default-character-set", OPT_DEFAULT_CHARSET,

1466

N_("(not used)"), 0,

1467

0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1468

{"delimiter", OPT_DELIMITER, N_("Delimiter to be used."), (char**) &delimiter_str,

1469

(char**) &delimiter_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1470

{"execute", 'e', N_("Execute command and quit. (Disables --force and history file)"), 0,

1471

0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1472

{"vertical", 'E', N_("Print the output of a query (rows) vertically."),

1473

(char**) &vertical, (char**) &vertical, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0,

1474

0},

1475

{"force", 'f', N_("Continue even if we get an sql error."),

1476

(char**) &ignore_errors, (char**) &ignore_errors, 0, GET_BOOL, NO_ARG, 0, 0,

1477

0, 0, 0, 0},

1478

{"named-commands", 'G',

1479

1480

(char**) &named_cmds, (char**) &named_cmds, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1481

0, 0},

1482

{"no-named-commands", 'g',

1483

N_("Named commands are disabled. Use \\* form only, or use named commands only in the beginning of a line ending with a semicolon (;) Since version 10.9 the client now starts with this option ENABLED by default! Disable with '-G'. Long format commands still work from the first line. WARNING: option deprecated; use --disable-named-commands instead."),

1484

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1485

{"ignore-spaces", 'i', N_("Ignore space after function names."), 0, 0, 0,

1486

GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1487

{"local-infile", OPT_LOCAL_INFILE, N_("Enable/disable LOAD DATA LOCAL INFILE."),

1488

(char**) &opt_local_infile,

1489

(char**) &opt_local_infile, 0, GET_BOOL, OPT_ARG, 0, 0, 0, 0, 0, 0},

1490

{"no-beep", 'b', N_("Turn off beep on error."), (char**) &opt_nobeep,

1491

(char**) &opt_nobeep, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1492

{"host", 'h', N_("Connect to host."), (char**) &current_host,

1493

(char**) &current_host, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1494

{"line-numbers", OPT_LINE_NUMBERS, N_("Write line numbers for errors."),

1495

(char**) &line_numbers, (char**) &line_numbers, 0, GET_BOOL,

1496

NO_ARG, 1, 0, 0, 0, 0, 0},

1497

{"skip-line-numbers", 'L', N_("Don't write line number for errors. WARNING: -L is deprecated, use long version of this option instead."), 0, 0, 0, GET_NO_ARG,

1498

NO_ARG, 0, 0, 0, 0, 0, 0},

1499

{"unbuffered", 'n', N_("Flush buffer after each query."), (char**) &unbuffered,

1500

(char**) &unbuffered, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1501

{"column-names", OPT_COLUMN_NAMES, N_("Write column names in results."),

1502

(char**) &column_names, (char**) &column_names, 0, GET_BOOL,

1503

NO_ARG, 1, 0, 0, 0, 0, 0},

1504

{"skip-column-names", 'N',

1505

N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."),

1506

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1507

{"set-variable", 'O',

1508

N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."),

1509

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1510

{"sigint-ignore", OPT_SIGINT_IGNORE, N_("Ignore SIGINT (CTRL-C)"),

1511

(char**) &opt_sigint_ignore, (char**) &opt_sigint_ignore, 0, GET_BOOL,

1512

NO_ARG, 0, 0, 0, 0, 0, 0},

1513

{"one-database", 'o',

1514

N_("Only update the default database. This is useful for skipping updates to other database in the update log."),

1515

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1516

{"pager", OPT_PAGER,

1517

1518

0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

1519

{"no-pager", OPT_NOPAGER,

1520

N_("Disable pager and print to stdout. See interactive help (\\h) also. WARNING: option deprecated; use --disable-pager instead."),

1521

0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1522

{"password", 'P',

1523

N_("Password to use when connecting to server. If password is not given it's asked from the tty."),

1524

0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},

1525

{"port", 'p', N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, ")

1526

N_("built-in default") " (" STRINGIFY_ARG(DRIZZLE_PORT) ").",

1527

0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1528

{"prompt", OPT_PROMPT, N_("Set the drizzle prompt to this value."),

1529

(char**) &current_prompt, (char**) &current_prompt, 0, GET_STR_ALLOC,

1530

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1531

{"quick", 'q',

1532

N_("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."),

1533

(char**) &quick, (char**) &quick, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1534

{"raw", 'r', N_("Write fields without conversion. Used with --batch."),

1535

(char**) &opt_raw_data, (char**) &opt_raw_data, 0, GET_BOOL, NO_ARG, 0, 0, 0,

1536

0, 0, 0},

1537

{"reconnect", OPT_RECONNECT, N_("Reconnect if the connection is lost. Disable with --disable-reconnect. This option is enabled by default."),

1538

(char**) &opt_reconnect, (char**) &opt_reconnect, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0},

1539

{"shutdown", OPT_SHUTDOWN, N_("Shutdown the server."),

1540

(char**) &opt_shutdown, (char**) &opt_shutdown, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1541

{"silent", 's', N_("Be more silent. Print results with a tab as separator, each row on new line."), 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0,

1542

0, 0},

1543

{"socket", 'S', N_("Socket file to use for connection."),

1544

(char**) &opt_drizzle_unix_port, (char**) &opt_drizzle_unix_port, 0, GET_STR_ALLOC,

1545

REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1546

{"table", 't', N_("Output in table format."), (char**) &output_tables,

1547

(char**) &output_tables, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1548

{"tee", OPT_TEE,

1549

N_("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."),

1550

0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1551

{"no-tee", OPT_NOTEE, N_("Disable outfile. See interactive help (\\h) also. WARNING: option deprecated; use --disable-tee instead"), 0, 0, 0, GET_NO_ARG,

1552

NO_ARG, 0, 0, 0, 0, 0, 0},

1553

{"user", 'u', N_("User for login if not current user."), (char**) &current_user,

1554

(char**) &current_user, 0, GET_STR_ALLOC, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

1555

{"safe-updates", 'U', N_("Only allow UPDATE and DELETE that uses keys."),

1556

(char**) &safe_updates, (char**) &safe_updates, 0, GET_BOOL, NO_ARG, 0, 0,

1557

0, 0, 0, 0},

1558

{"i-am-a-dummy", 'U', N_("Synonym for option --safe-updates, -U."),

1559

(char**) &safe_updates, (char**) &safe_updates, 0, GET_BOOL, NO_ARG, 0, 0,

1560

0, 0, 0, 0},

1561

{"verbose", 'v', N_("Write more. (-v -v -v gives the table output format)."), 0,

1562

0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1563

{"version", 'V', N_("Output version information and exit."), 0, 0, 0,

1564

GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

1565

{"wait", 'w', N_("Wait and retry if connection is down."), 0, 0, 0, GET_NO_ARG,

1566

NO_ARG, 0, 0, 0, 0, 0, 0},

1567

{"connect_timeout", OPT_CONNECT_TIMEOUT,

1568

N_("Number of seconds before connection timeout."),

1569

(char**) &opt_connect_timeout,

1570

(char**) &opt_connect_timeout, 0, GET_UINT32, REQUIRED_ARG, 0, 0, 3600*12, 0,

1571

0, 0},

1572

{"max_input_line", OPT_MAX_INPUT_LINE,

1573

N_("Max length of input line"),

1574

(char**) &opt_max_input_line, (char**) &opt_max_input_line, 0,

1575

GET_UINT32, REQUIRED_ARG, 16 *1024L*1024L, 4096,

1576

(int64_t) 2*1024L*1024L*1024L, MALLOC_OVERHEAD, 1024, 0},

1577

{"select_limit", OPT_SELECT_LIMIT,

1578

N_("Automatic limit for SELECT when using --safe-updates"),

1579

(char**) &select_limit,

1580

(char**) &select_limit, 0, GET_UINT32, REQUIRED_ARG, 1000L, 1, ULONG_MAX,

1581

0, 1, 0},

1582

{"max_join_size", OPT_MAX_JOIN_SIZE,

1583

N_("Automatic limit for rows in a join when using --safe-updates"),

1584

(char**) &max_join_size,

1585

(char**) &max_join_size, 0, GET_UINT32, REQUIRED_ARG, 1000000L, 1, ULONG_MAX,

1586

0, 1, 0},

1587

{"secure-auth", OPT_SECURE_AUTH, N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"), (char**) &opt_secure_auth,

1588

(char**) &opt_secure_auth, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1589

{"show-warnings", OPT_SHOW_WARNINGS, N_("Show warnings after every statement."),

1590

(char**) &show_warnings, (char**) &show_warnings, 0, GET_BOOL, NO_ARG,

1591

0, 0, 0, 0, 0, 0},

1592

{"show-progress-size", OPT_SHOW_PROGRESS_SIZE, N_("Number of lines before each import progress report."),

1593

(char**) &show_progress_size, (char**) &show_progress_size, 0, GET_UINT32, REQUIRED_ARG,

1594

0, 0, 0, 0, 0, 0},

1595

{"ping", OPT_PING, N_("Ping the server to check if it's alive."),

1596

(char**) &opt_ping, (char**) &opt_ping, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},

1597

{ 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

1598

};

1599

1600

1601

static void usage(int version)

1602

{

1603

const char* readline= "readline";

1604

1605

printf(_("%s Ver %s Distrib %s, for %s-%s (%s) using %s %s\n"),

1606

my_progname, VER.c_str(), drizzle_version(),

1607

HOST_VENDOR, HOST_OS, HOST_CPU,

1608

readline, rl_library_version);

1609

1610

if (version)

1611

return;

1612

1613

"This software comes with ABSOLUTELY NO WARRANTY. "

1614

"This is free software,\n"

1615

"and you are welcome to modify and redistribute it "

1616

"under the GPL license\n"));

1617

printf(_("Usage: %s [OPTIONS] [database]\n"), my_progname);

1618

my_print_help(my_long_options);

1619

print_defaults("drizzle", load_default_groups);

1620

my_print_variables(my_long_options);

1621

}

1622

1623

1624

extern "C" bool

1625

get_one_option(int optid, const struct my_option *, char *argument)

1626

{

1627

char *endchar= NULL;

1628

uint64_t temp_drizzle_port= 0;

1629

1630

switch(optid) {

1631

case OPT_DEFAULT_CHARSET:

1632

default_charset_used= 1;

1633

break;

1634

case OPT_DELIMITER:

1635

if (argument == disabled_my_option)

1636

{

1637

strcpy(delimiter, DEFAULT_DELIMITER);

1638

}

1639

else

1640

{

1641

/* Check that delimiter does not contain a backslash */

1642

if (!strstr(argument, "\\"))

1643

{

1644

strncpy(delimiter, argument, sizeof(delimiter) - 1);

1645

}

1646

else

1647

{

1648

put_info(_("DELIMITER cannot contain a backslash character"),

1649

INFO_ERROR,0,0);

1650

return false;

1651

}

1652

}

1653

delimiter_length= (uint32_t)strlen(delimiter);

1654

delimiter_str= delimiter;

1655

break;

1656

case OPT_TEE:

1657

if (argument == disabled_my_option)

1658

{

1659

if (opt_outfile)

1660

end_tee();

1661

}

1662

else

1663

init_tee(argument);

1664

break;

1665

case OPT_NOTEE:

1666

printf(_("WARNING: option deprecated; use --disable-tee instead.\n"));

1667

if (opt_outfile)

1668

end_tee();

1669

break;

1670

case OPT_PAGER:

1671

if (argument == disabled_my_option)

1672

opt_nopager= 1;

1673

else

1674

{

1675

opt_nopager= 0;

1676

if (argument && strlen(argument))

1677

{

1678

default_pager_set= 1;

1679

strncpy(pager, argument, sizeof(pager) - 1);

1680

strcpy(default_pager, pager);

1681

}

1682

else if (default_pager_set)

1683

strcpy(pager, default_pager);

1684

else

1685

opt_nopager= 1;

1686

}

1687

break;

1688

case OPT_NOPAGER:

1689

printf(_("WARNING: option deprecated; use --disable-pager instead.\n"));

1690

opt_nopager= 1;

1691

break;

1692

case OPT_SERVER_ARG:

1693

printf(_("WARNING: --server-arg option not supported in this configuration.\n"));

1694

break;

1695

case 'A':

1696

opt_rehash= 0;

1697

break;

1698

case 'N':

1699

column_names= 0;

1700

break;

1701

case 'e':

1702

status.batch= 1;

1703

status.add_to_history= 0;

1704

if (status.line_buff == NULL)

1705

status.line_buff= new(std::nothrow) LineBuffer(opt_max_input_line,NULL);

1706

if (status.line_buff == NULL)

1707

{

1708

my_end(0);

1709

exit(1);

1710

}

1711

status.line_buff->addString(argument);

1712

break;

1713

case 'o':

1714

if (argument == disabled_my_option)

1715

one_database= 0;

1716

else

1717

one_database= skip_updates= 1;

1718

break;

1719

case 'p':

1720

temp_drizzle_port= (uint64_t) strtoul(argument, &endchar, 10);

1721

/* if there is an alpha character this is not a valid port */

1722

if (strlen(endchar) != 0)

1723

{

1724

put_info(_("Non-integer value supplied for port. If you are trying to enter a password please use --password instead."), INFO_ERROR, 0, 0);

1725

return false;

1726

}

1727

/* If the port number is > 65535 it is not a valid port

1728

This also helps with potential data loss casting unsigned long to a

1729

uint32_t. */

1730

if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))

1731

{

1732

put_info(_("Value supplied for port is not valid."), INFO_ERROR, 0, 0);

1733

return false;

1734

}

1735

else

1736

{

1737

opt_drizzle_port= (uint32_t) temp_drizzle_port;

1738

}

1739

break;

1740

case 'P':

1741

/* Don't require password */

1742

if (argument == disabled_my_option)

1743

{

1744

argument= (char*) "";

1745

}

1746

if (argument)

1747

{

1748

char *start= argument;

1749

free(opt_password);

1750

opt_password= strdup(argument);

1751

while (*argument)

1752

{

1753

/* Overwriting password with 'x' */

1754

*argument++= 'x';

1755

}

1756

if (*start)

1757

{

1758

start[1]= 0;

1759

}

1760

tty_password= 0;

1761

}

1762

else

1763

{

1764

tty_password= 1;

1765

}

1766

break;

1767

case 's':

1768

if (argument == disabled_my_option)

1769

opt_silent= 0;

1770

else

1771

opt_silent++;

1772

break;

1773

case 'v':

1774

if (argument == disabled_my_option)

1775

verbose= 0;

1776

else

1777

verbose++;

1778

break;

1779

case 'B':

1780

status.batch= 1;

1781

status.add_to_history= 0;

1782

set_if_bigger(opt_silent,1); // more silent

1783

break;

1784

case 'V':

1785

usage(1);

1786

exit(0);

1787

case 'I':

1788

case '?':

1789

usage(0);

1790

exit(0);

1791

}

1792

return 0;

1793

}

1794

1795

1796

static int get_options(int argc, char **argv)

1899

1797

{

1900

1798

char *tmp, *pagpoint;

1901

1799

int ho_error;

1902

1800

1903

1801

tmp= (char *) getenv("DRIZZLE_HOST");

1904

1802

if (tmp)

1905

current_host.assign(tmp);

1803

current_host= strdup(tmp);

1906

1804

1907

1805

pagpoint= getenv("PAGER");

1908

1806

if (!((char*) (pagpoint)))

1909

1807

{

1910

pager.assign("stdout");

1808

strcpy(pager, "stdout");

1911

1809

opt_nopager= 1;

1912

1810

}

1913

1811

else

1914

{

1915

pager.assign(pagpoint);

1916

}

1917

default_pager.assign(pager);

1918

1919

1920

1921

if (status.getBatch()) /* disable pager and outfile in this case */

1922

{

1923

default_pager.assign("stdout");

1924

pager.assign("stdout");

1812

strcpy(pager, pagpoint);

1813

strcpy(default_pager, pager);

1814

1815

if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))

1816

exit(ho_error);

1817

1818

if (status.batch) /* disable pager and outfile in this case */

1819

{

1820

strcpy(default_pager, "stdout");

1821

strcpy(pager, "stdout");

1925

1822

opt_nopager= 1;

1926

1823

default_pager_set= 0;

1927

1824

opt_outfile= 0;

1929

1826

connect_flag= DRIZZLE_CAPABILITIES_NONE; /* Not in interactive mode */

1930

1827

}

1931

1828

1829

if (argc > 1)

1830

{

1831

usage(0);

1832

exit(1);

1833

}

1834

if (argc == 1)

1835

{

1836

skip_updates= 0;

1837

free(current_db);

1838

current_db= strdup(*argv);

1839

}

1932

1840

if (tty_password)

1933

1841

opt_password= client_get_tty_password(NULL);

1842

if (debug_info_flag)

1843

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

1844

if (debug_check_flag)

1845

my_end_arg= MY_CHECK_ERROR;

1934

1846

return(0);

1935

1847

}

1936

1848

1940

1852

char in_string=0;

1941

1853

uint32_t line_number=0;

1942

1854

bool ml_comment= 0;

1943

Commands *com;

1944

status.setExitStatus(1);

1855

COMMANDS *com;

1856

status.exit_status=1;

1945

1857

1946

1858

for (;;)

1947

1859

{

1948

1860

if (!interactive)

1949

1861

{

1950

if (status.getLineBuff())

1951

line= status.getLineBuff()->readline();

1862

if (status.line_buff)

1863

line= status.line_buff->readline();

1952

1864

else

1953

1865

line= 0;

1954

1866

1959

1871

fprintf(stderr, _("Processing line: %"PRIu32"\n"), line_number);

1960

1872

}

1961

1873

if (!glob_buffer->empty())

1962

status.setQueryStartLine(line_number);

1874

status.query_start_line= line_number;

1963

1875

}

1964

1876

else

1965

1877

{

1966

string prompt(ml_comment

1967

? " /*> "

1968

: glob_buffer->empty()

1969

? construct_prompt()

1970

: not in_string

1971

? " -> "

1972

: in_string == '\''

1973

? " '> "

1974

: in_string == '`'

1975

? " `> "

1976

: " \"> ");

1878

const char *prompt= (const char*) (ml_comment ? " /*> " :

1879

(glob_buffer->empty())

1880

? construct_prompt()

1881

: !in_string ? " -> " :

1882

in_string == '\'' ?

1883

" '> " : (in_string == '`' ?

1884

" `> " :

1885

" \"> "));

1977

1886

if (opt_outfile && glob_buffer->empty())

1978

1887

fflush(OUTFILE);

1979

1888

1980

1889

if (opt_outfile)

1981

fputs(prompt.c_str(), OUTFILE);

1982

line= readline(prompt.c_str());

1890

fputs(prompt, OUTFILE);

1891

line= readline(prompt);

1983

1892

1984

1893

When Ctrl+d or Ctrl+z is pressed, the line may be NULL on some OS

1985

1894

which may cause coredump.

1990

1899

// End of file

1991

1900

if (!line)

1992

1901

{

1993

status.setExitStatus(0);

1902

status.exit_status=0;

1994

1903

break;

1995

1904

}

1996

1905

2006

1915

// If buffer was emptied

2007

1916

if (glob_buffer->empty())

2008

1917

in_string=0;

2009

if (interactive && status.getAddToHistory() && not_in_history(line))

1918

if (interactive && status.add_to_history && not_in_history(line))

2010

1919

add_history(line);

2011

1920

continue;

2012

1921

}

2015

1924

}

2016

1925

/* if in batch mode, send last query even if it doesn't end with \g or go */

2017

1926

2018

if (!interactive && !status.getExitStatus())

1927

if (!interactive && !status.exit_status)

2019

1928

{

2020

1929

remove_cntrl(glob_buffer);

2021

1930

if (!glob_buffer->empty())

2022

1931

{

2023

status.setExitStatus(1);

1932

status.exit_status=1;

2024

1933

if (com_go(glob_buffer,line) <= 0)

2025

status.setExitStatus(0);

1934

status.exit_status=0;

2026

1935

}

2027

1936

}

2028

1937

2029

return status.getExitStatus();

1938

return status.exit_status;

2030

1939

}

2031

1940

2032

1941

2033

static Commands *find_command(const char *name,char cmd_char)

1942

static COMMANDS *find_command(const char *name,char cmd_char)

2034

1943

{

2035

1944

uint32_t len;

2036

1945

const char *end;

2042

1951

}

2043

1952

else

2044

1953

{

2045

while (isspace(*name))

1954

while (my_isspace(charset_info,*name))

2046

1955

name++;

2047

1956

2048

1957

If there is an \\g in the row or if the row has a delimiter but

2051

1960

2052

1961

if (strstr(name, "\\g") || (strstr(name, delimiter) &&

2053

1962

!(strlen(name) >= 9 &&

2054

!strcmp(name, "delimiter"))))

2055

return(NULL);

1963

!my_strnncoll(charset_info,

1964

(unsigned char*) name, 9,

1965

(const unsigned char*) "delimiter",

1966

9))))

1967

return((COMMANDS *) 0);

2056

1968

if ((end=strcont(name," \t")))

2057

1969

{

2058

1970

len=(uint32_t) (end - name);

2059

while (isspace(*end))

1971

while (my_isspace(charset_info,*end))

2060

1972

end++;

2061

1973

if (!*end)

2062

1974

end=0; // no arguments to function

2065

1977

len=(uint32_t) strlen(name);

2066

1978

}

2067

1979

2068

for (uint32_t i= 0; commands[i].getName(); i++)

1980

for (uint32_t i= 0; commands[i].name; i++)

2069

1981

{

2070

1982

if (commands[i].func &&

2071

((name && !strncmp(name, commands[i].getName(), len)

2072

&& !commands[i].getName()[len] && (!end || (end && commands[i].getTakesParams()))) || (!name && commands[i].getCmdChar() == cmd_char)))

1983

((name && !my_strnncoll(charset_info,(const unsigned char*)name,len, (const unsigned char*)commands[i].name,len) && !commands[i].name[len] && (!end || (end && commands[i].takes_params))) || (!name && commands[i].cmd_char == cmd_char)))

2073

1984

{

2074

1985

return(&commands[i]);

2075

1986

}

2076

1987

}

2077

return(NULL);

1988

return((COMMANDS *) 0);

2078

1989

}

2079

1990

2080

1991

2083

1994

{

2084

1995

unsigned char inchar;

2085

1996

char *pos, *out;

2086

Commands *com;

1997

COMMANDS *com;

2087

1998

bool need_space= 0;

2088

1999

bool ss_comment= 0;

2089

2000

2090

2001

2091

2002

if (!line[0] && (buffer->empty()))

2092

2003

return(0);

2093

if (status.getAddToHistory() && line[0] && not_in_history(line))

2004

if (status.add_to_history && line[0] && not_in_history(line))

2094

2005

add_history(line);

2095

2006

char *end_of_line=line+(uint32_t) strlen(line);

2096

2007

2099

2010

if (!preserve_comments)

2100

2011

{

2101

2012

// Skip spaces at the beggining of a statement

2102

if (isspace(inchar) && (out == line) &&

2013

if (my_isspace(charset_info,inchar) && (out == line) &&

2103

2014

(buffer->empty()))

2104

2015

continue;

2105

2016

}

2106

2017

2107

2018

// Accept multi-byte characters as-is

2108

if (not drizzled::utf8::is_single(*pos))

2019

int length;

2020

if (use_mb(charset_info) &&

2021

(length= my_ismbchar(charset_info, pos, end_of_line)))

2109

2022

{

2110

int length;

2111

if ((length= drizzled::utf8::sequence_length(*pos)))

2023

if (!*ml_comment || preserve_comments)

2112

2024

{

2113

if (!*ml_comment || preserve_comments)

2114

{

2115

while (length--)

2116

*out++ = *pos++;

2117

pos--;

2118

}

2119

else

2120

pos+= length - 1;

2121

continue;

2025

while (length--)

2026

*out++ = *pos++;

2027

pos--;

2122

2028

}

2029

else

2030

pos+= length - 1;

2031

continue;

2123

2032

}

2124

2033

if (!*ml_comment && inchar == '\\' &&

2125

2034

!(*in_string && (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))

2145

2054

2146

2055

if ((*com->func)(buffer,pos-1) > 0)

2147

2056

return(1); // Quit

2148

if (com->getTakesParams())

2057

if (com->takes_params)

2149

2058

{

2150

2059

if (ss_comment)

2151

2060

{

2188

2097

}

2189

2098

else if (!*ml_comment && !*in_string &&

2190

2099

(end_of_line - pos) >= 10 &&

2191

!strncmp(pos, "delimiter ", 10))

2100

!my_strnncoll(charset_info, (unsigned char*) pos, 10,

2101

(const unsigned char*) "delimiter ", 10))

2192

2102

{

2193

2103

// Flush previously accepted characters

2194

2104

if (out != line)

2225

2135

2226

2136

if (preserve_comments)

2227

2137

{

2228

while (isspace(*pos))

2138

while (my_isspace(charset_info, *pos))

2229

2139

*out++= *pos++;

2230

2140

}

2231

2141

// Flush previously accepted characters

2238

2148

if (preserve_comments && ((*pos == '#') ||

2239

2149

((*pos == '-') &&

2240

2150

(pos[1] == '-') &&

2241

isspace(pos[2]))))

2151

my_isspace(charset_info, pos[2]))))

2242

2152

{

2243

2153

// Add trailing single line comments to this statement

2244

2154

buffer->append(pos);

2265

2175

&& (inchar == '#'

2266

2176

|| (inchar == '-'

2267

2177

&& pos[1] == '-'

2268

&& isspace(pos[2])))))

2178

&& my_isspace(charset_info,pos[2])))))

2269

2179

{

2270

2180

// Flush previously accepted characters

2271

2181

if (out != line)

2331

2241

*in_string= (char) inchar;

2332

2242

if (!*ml_comment || preserve_comments)

2333

2243

{

2334

if (need_space && !isspace((char)inchar))

2244

if (need_space && !my_isspace(charset_info, (char)inchar))

2335

2245

*out++= ' ';

2336

2246

need_space= 0;

2337

2247

*out++= (char) inchar;

2342

2252

{

2343

2253

*out++='\n';

2344

2254

uint32_t length=(uint32_t) (out-line);

2345

if ((buffer->length() + length) > opt_max_input_line)

2346

{

2347

status.setExitStatus(1);

2348

put_info(_("Not found a delimiter within max_input_line of input"), INFO_ERROR, 0, 0);

2349

return 1;

2350

}

2351

2255

if ((!*ml_comment || preserve_comments))

2352

2256

buffer->append(line, length);

2353

2257

}

2464

2368

2465

2369

char **mysql_completion (const char *text, int, int)

2466

2370

{

2467

if (!status.getBatch() && !quick)

2371

if (!status.batch && !quick)

2468

2372

return rl_completion_matches(text, new_command_generator);

2469

2373

else

2470

2374

return (char**) 0;

2533

2437

2534

2438

static void build_completion_hash(bool rehash, bool write_info)

2535

2439

{

2536

Commands *cmd=commands;

2440

COMMANDS *cmd=commands;

2537

2441

drizzle_return_t ret;

2538

2442

drizzle_result_st databases,tables,fields;

2539

2443

drizzle_row_t database_row,table_row;

2540

2444

drizzle_column_st *sql_field;

2541

2445

string tmp_str, tmp_str_lower;

2542

2446

2543

if (status.getBatch() || quick || current_db.empty())

2447

if (status.batch || quick || !current_db)

2544

2448

return; // We don't need completion in batches

2545

2449

if (!rehash)

2546

2450

return;

2548

2452

completion_map.clear();

2549

2453

2550

2454

/* hash this file's known subset of SQL commands */

2551

while (cmd->getName()) {

2552

tmp_str= cmd->getName();

2455

while (cmd->name) {

2456

tmp_str= cmd->name;

2553

2457

tmp_str_lower= lower_string(tmp_str);

2554

2458

completion_map[tmp_str_lower]= tmp_str;

2555

2459

cmd++;

2593

2497

{

2594

2498

if (drizzle_result_row_count(&tables) > 0 && !opt_silent && write_info)

2595

2499

{

2596

tee_fprintf(stdout,

2597

_("Reading table information for completion of "

2598

"table and column names\n"

2599

"You can turn off this feature to get a quicker "

2600

"startup with -A\n\n"));

2500

tee_fprintf(stdout, _("\

2501

Reading table information for completion of table and column names\n \

2502

You can turn off this feature to get a quicker startup with -A\n\n"));

2601

2503

}

2602

2504

while ((table_row=drizzle_row_next(&tables)))

2603

2505

{

2623

2525

{

2624

2526

string query;

2625

2527

2626

query.append("show fields in `");

2528

query.append("show fields in '");

2627

2529

query.append(table_row[0]);

2628

query.append("`");

2530

query.append("'");

2629

2531

2630

2532

if (drizzle_query(&con, &fields, query.c_str(), query.length(),

2631

2533

&ret) != NULL)

2655

2557

2656

2558

/* for gnu readline */

2657

2559

2560

#ifndef HAVE_INDEX

2561

extern "C" {

2562

extern char *index(const char *,int c),*rindex(const char *,int);

2563

2564

char *index(const char *s,int c)

2565

{

2566

for (;;)

2567

{

2568

if (*s == (char) c) return (char*) s;

2569

if (!*s++) return NULL;

2570

}

2571

}

2572

2573

char *rindex(const char *s,int c)

2574

{

2575

2576

2577

t = NULL;

2578

do if (*s == (char) c) t = (char*) s; while (*s++);

2579

return (char*) t;

2580

}

2581

}

2582

#endif

2583

2658

2584

2659

2585

static int reconnect(void)

2660

2586

{

2675

2601

drizzle_return_t ret;

2676

2602

drizzle_result_st res;

2677

2603

2678

current_db.erase();

2679

current_db= "";

2604

free(current_db);

2605

current_db= NULL;

2680

2606

/* In case of error below current_db will be NULL */

2681

2607

if (drizzle_query_str(&con, &res, "SELECT DATABASE()", &ret) != NULL)

2682

2608

{

2685

2611

{

2686

2612

drizzle_row_t row= drizzle_row_next(&res);

2687

2613

if (row[0])

2688

current_db.assign(row[0]);

2614

current_db= strdup(row[0]);

2689

2615

drizzle_result_free(&res);

2690

2616

}

2691

2617

}

2695

2621

The different commands

2696

2622

***************************************************************************/

2697

2623

2698

int drizzleclient_real_query_for_lazy(const char *buf, size_t length,

2624

int drizzleclient_real_query_for_lazy(const char *buf, int length,

2699

2625

drizzle_result_st *result,

2700

2626

uint32_t *error_code)

2701

2627

{

2734

2660

return 0;

2735

2661

2736

2662

if (drizzle_con_error(&con)[0])

2737

{

2738

int ret= put_error(&con, result);

2739

drizzle_result_free(result);

2740

return ret;

2741

}

2663

return put_error(&con, result);

2742

2664

return 0;

2743

2665

}

2744

2666

2747

2669

{

2748

2670

2749

2671

char buff[32], *end;

2750

std::vector<char> output_buff;

2751

output_buff.resize(512);

2752

2672

2753

2673

put_info(_("List of all Drizzle commands:"), INFO_INFO,0,0);

2754

2674

if (!named_cmds)

2755

{

2756

snprintf(&output_buff[0], output_buff.size(),

2757

_("Note that all text commands must be first on line and end with '%s' or \\g"),

2758

delimiter);

2759

put_info(&output_buff[0], INFO_INFO, 0, 0);

2760

}

2761

for (i = 0; commands[i].getName(); i++)

2762

{

2763

end= strcpy(buff, commands[i].getName());

2764

end+= strlen(commands[i].getName());

2765

for (j= (int)strlen(commands[i].getName()); j < 10; j++)

2675

put_info(_("Note that all text commands must be first on line and end with ';'"),INFO_INFO,0,0);

2676

for (i = 0; commands[i].name; i++)

2677

{

2678

end= strcpy(buff, commands[i].name);

2679

end+= strlen(commands[i].name);

2680

for (j= (int)strlen(commands[i].name); j < 10; j++)

2766

2681

end= strcpy(end, " ")+1;

2767

2682

if (commands[i].func)

2768

2683

tee_fprintf(stdout, "%s(\\%c) %s\n", buff,

2769

commands[i].getCmdChar(), _(commands[i].getDoc()));

2684

commands[i].cmd_char, _(commands[i].doc));

2770

2685

}

2771

2686

tee_fprintf(stdout, "\n");

2772

2687

buffer->clear();

2777

2692

static int

2778

2693

com_clear(string *buffer, const char *)

2779

2694

{

2780

if (status.getAddToHistory())

2695

if (status.add_to_history)

2781

2696

fix_history(buffer);

2782

2697

buffer->clear();

2783

2698

return 0;

2810

2725

if (buffer->empty())

2811

2726

{

2812

2727

// Ignore empty quries

2813

if (status.getBatch())

2728

if (status.batch)

2814

2729

return 0;

2815

2730

return put_info(_("No query specified\n"),INFO_ERROR,0,0);

2816

2731

2835

2750

executing_query= 1;

2836

2751

error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length(),&result, &error_code);

2837

2752

2838

if (status.getAddToHistory())

2753

if (status.add_to_history)

2839

2754

{

2840

2755

buffer->append(vertical ? "\\G" : delimiter);

2841

2756

/* Append final command onto history */

2956

2871

if (show_warnings == 1 && (warnings >= 1 || error))

2957

2872

print_warnings(error_code);

2958

2873

2959

if (!error && !status.getBatch() &&

2874

if (!error && !status.batch &&

2960

2875

drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)

2961

2876

{

2962

2877

get_current_db();

2971

2886

{

2972

2887

if (!opt_nopager)

2973

2888

{

2974

if (!(PAGER= popen(pager.c_str(), "w")))

2889

if (!(PAGER= popen(pager, "w")))

2975

2890

{

2976

tee_fprintf(stdout,_( "popen() failed! defaulting PAGER to stdout!\n"));

2891

tee_fprintf(stdout, "popen() failed! defaulting PAGER to stdout!\n");

2977

2892

PAGER= stdout;

2978

2893

}

2979

2894

}

2995

2910

end_tee();

2996

2911

if (!(new_outfile= fopen(file_name, "a")))

2997

2912

{

2998

tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);

2913

tee_fprintf(stdout, "Error logging to file '%s'\n", file_name);

2999

2914

return;

3000

2915

}

3001

2916

OUTFILE = new_outfile;

3002

outfile.assign(file_name);

3003

tee_fprintf(stdout, _("Logging to file '%s'\n"), file_name);

2917

strncpy(outfile, file_name, FN_REFLEN-1);

2918

tee_fprintf(stdout, "Logging to file '%s'\n", file_name);

3004

2919

opt_outfile= 1;

3005

2920

3006

2921

return;

3084

2999

3085

3000

while ((field = drizzle_column_next(result)))

3086

3001

{

3087

tee_fprintf(PAGER, _("Field %3u: `%s`\n"

3002

tee_fprintf(PAGER, "Field %3u: `%s`\n"

3088

3003

"Catalog: `%s`\n"

3089

3004

"Database: `%s`\n"

3090

3005

"Table: `%s`\n"

3091

3006

"Org_table: `%s`\n"

3092

"Type: UTF-8\n"

3007

"Type: %s\n"

3093

3008

"Collation: %s (%u)\n"

3094

3009

"Length: %lu\n"

3095

3010

"Max_length: %lu\n"

3096

3011

"Decimals: %u\n"

3097

"Flags: %s\n\n"),

3012

"Flags: %s\n\n",

3098

3013

++i,

3099

3014

drizzle_column_name(field), drizzle_column_catalog(field),

3100

3015

drizzle_column_db(field), drizzle_column_table(field),

3101

3016

drizzle_column_orig_table(field),

3102

3017

fieldtype2str(drizzle_column_type(field)),

3018

get_charset_name(drizzle_column_charset(field)),

3103

3019

drizzle_column_charset(field), drizzle_column_size(field),

3104

3020

drizzle_column_max_size(field), drizzle_column_decimals(field),

3105

3021

fieldflags2str(drizzle_column_flags(field)));

3107

3023

tee_puts("", PAGER);

3108

3024

}

3109

3025

3026

3110

3027

static void

3111

3028

print_table_data(drizzle_result_st *result)

3112

3029

{

3113

3030

drizzle_row_t cur;

3114

3031

drizzle_return_t ret;

3115

3032

drizzle_column_st *field;

3116

std::vector<bool> num_flag;

3033

bool *num_flag;

3117

3034

string separator;

3118

3035

3119

3036

separator.reserve(256);

3120

3037

3121

num_flag.resize(drizzle_result_column_count(result));

3038

num_flag=(bool*) malloc(sizeof(bool)*drizzle_result_column_count(result));

3122

3039

if (column_types_flag)

3123

3040

{

3124

3041

print_field_types(result);

3138

3055

/* Check if the max_byte value is really the maximum in terms

3139

3056

of visual length since multibyte characters can affect the

3140

3057

length of the separator. */

3141

length= drizzled::utf8::char_length(drizzle_column_name(field));

3058

length= charset_info->cset->numcells(charset_info,

3059

drizzle_column_name(field),

3060

drizzle_column_name(field) +

3061

name_length);

3142

3062

3143

3063

if (name_length == drizzle_column_max_size(field))

3144

3064

{

3176

3096

for (uint32_t off=0; (field = drizzle_column_next(result)) ; off++)

3177

3097

{

3178

3098

uint32_t name_length= (uint32_t) strlen(drizzle_column_name(field));

3179

uint32_t numcells= drizzled::utf8::char_length(drizzle_column_name(field));

3099

uint32_t numcells= charset_info->cset->numcells(charset_info,

3100

drizzle_column_name(field),

3101

drizzle_column_name(field) +

3102

name_length);

3180

3103

uint32_t display_length= drizzle_column_max_size(field) + name_length -

3181

3104

numcells;

3182

3105

tee_fprintf(PAGER, " %-*s |",(int) min(display_length,

3239

3162

We need to find how much screen real-estate we will occupy to know how

3240

3163

many extra padding-characters we should send with the printing function.

3241

3164

3242

visible_length= drizzled::utf8::char_length(buffer);

3165

visible_length= charset_info->cset->numcells(charset_info, buffer, buffer + data_length);

3243

3166

extra_padding= data_length - visible_length;

3244

3167

3245

3168

if (field_max_length > MAX_COLUMN_LENGTH)

3259

3182

drizzle_row_free(result, cur);

3260

3183

}

3261

3184

tee_puts(separator.c_str(), PAGER);

3185

free(num_flag);

3262

3186

}

3263

3187

3264

3188

/**

3406

3330

drizzle_row_t cur;

3407

3331

uint64_t num_rows;

3408

3332

uint32_t new_code= 0;

3409

FILE *out;

3410

3333

3411

3334

/* Get the warnings */

3412

3335

query= "show warnings";

3432

3355

}

3433

3356

3434

3357

/* Print the warnings */

3435

if (status.getBatch())

3436

{

3437

out= stderr;

3438

}

3439

else

3440

{

3441

init_pager();

3442

out= PAGER;

3443

}

3358

init_pager();

3444

3359

3445

3360

{

3446

tee_fprintf(out, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3361

tee_fprintf(PAGER, "%s (Code %s): %s\n", cur[0], cur[1], cur[2]);

3447

3362

} while ((cur= drizzle_row_next(&result)));

3448

3449

if (not status.getBatch())

3450

end_pager();

3363

end_pager();

3451

3364

3452

3365

end:

3453

3366

drizzle_result_free(&result);

3466

3379

else for (const char *end=pos+length ; pos != end ; pos++)

3467

3380

{

3468

3381

int l;

3469

if ((l = drizzled::utf8::sequence_length(*pos)))

3382

if (use_mb(charset_info) &&

3383

(l = my_ismbchar(charset_info, pos, end)))

3470

3384

{

3471

3385

while (l--)

3472

3386

tee_putc(*pos++, PAGER);

3543

3457

char file_name[FN_REFLEN], *end;

3544

3458

const char *param;

3545

3459

3546

if (status.getBatch())

3460

if (status.batch)

3547

3461

return 0;

3548

while (isspace(*line))

3462

while (my_isspace(charset_info,*line))

3549

3463

line++;

3550

if (!(param =strchr(line, ' '))) // if outfile wasn't given, use the default

3464

if (!(param = strchr(line, ' '))) // if outfile wasn't given, use the default

3551

3465

{

3552

if (outfile.empty())

3466

if (!strlen(outfile))

3553

3467

{

3554

printf(_("No previous outfile available, you must give a filename!\n"));

3468

printf("No previous outfile available, you must give a filename!\n");

3555

3469

return 0;

3556

3470

}

3557

3471

else if (opt_outfile)

3558

3472

{

3559

tee_fprintf(stdout, _("Currently logging to file '%s'\n"), outfile.c_str());

3473

tee_fprintf(stdout, "Currently logging to file '%s'\n", outfile);

3560

3474

return 0;

3561

3475

}

3562

3476

else

3563

param= outfile.c_str(); //resume using the old outfile

3477

param = outfile; //resume using the old outfile

3564

3478

}

3565

3479

3566

/* @TODO: Replace this with string methods */

3567

3480

/* eliminate the spaces before the parameters */

3568

while (isspace(*param))

3481

while (my_isspace(charset_info,*param))

3569

3482

param++;

3570

3483

strncpy(file_name, param, sizeof(file_name) - 1);

3571

3484

end= file_name + strlen(file_name);

3572

3485

/* remove end space from command line */

3573

while (end > file_name && (isspace(end[-1]) ||

3574

iscntrl(end[-1])))

3486

while (end > file_name && (my_isspace(charset_info,end[-1]) ||

3487

my_iscntrl(charset_info,end[-1])))

3575

3488

end--;

3576

3489

end[0]= 0;

3577

3490

if (end == file_name)

3578

3491

{

3579

printf(_("No outfile specified!\n"));

3492

printf("No outfile specified!\n");

3580

3493

return 0;

3581

3494

}

3582

3495

init_tee(file_name);

3589

3502

{

3590

3503

if (opt_outfile)

3591

3504

end_tee();

3592

tee_fprintf(stdout, _("Outfile disabled.\n"));

3505

tee_fprintf(stdout, "Outfile disabled.\n");

3593

3506

return 0;

3594

3507

}

3595

3508

3600

3513

static int

3601

3514

com_pager(string *, const char *line)

3602

3515

{

3516

char pager_name[FN_REFLEN], *end;

3603

3517

const char *param;

3604

3518

3605

if (status.getBatch())

3519

if (status.batch)

3606

3520

return 0;

3607

3521

/* Skip spaces in front of the pager command */

3608

while (isspace(*line))

3522

while (my_isspace(charset_info, *line))

3609

3523

line++;

3610

3524

/* Skip the pager command */

3611

3525

param= strchr(line, ' ');

3612

3526

/* Skip the spaces between the command and the argument */

3613

while (param && isspace(*param))

3527

while (param && my_isspace(charset_info, *param))

3614

3528

param++;

3615

if (!param || (*param == '\0')) // if pager was not given, use the default

3529

if (!param || !strlen(param)) // if pager was not given, use the default

3616

3530

{

3617

3531

if (!default_pager_set)

3618

3532

{

3619

tee_fprintf(stdout, _("Default pager wasn't set, using stdout.\n"));

3533

tee_fprintf(stdout, "Default pager wasn't set, using stdout.\n");

3620

3534

opt_nopager=1;

3621

pager.assign("stdout");

3535

strcpy(pager, "stdout");

3622

3536

PAGER= stdout;

3623

3537

return 0;

3624

3538

}

3625

pager.assign(default_pager);

3539

strcpy(pager, default_pager);

3626

3540

}

3627

3541

else

3628

3542

{

3629

string pager_name(param);

3630

string::iterator end= pager_name.end();

3631

while (end > pager_name.begin() &&

3632

(isspace(*(end-1)) || iscntrl(*(end-1))))

3633

--end;

3634

pager_name.erase(end, pager_name.end());

3635

pager.assign(pager_name);

3636

default_pager.assign(pager_name);

3543

end= strncpy(pager_name, param, sizeof(pager_name)-1);

3544

end+= strlen(pager_name);

3545

while (end > pager_name && (my_isspace(charset_info,end[-1]) ||

3546

my_iscntrl(charset_info,end[-1])))

3547

end--;

3548

end[0]=0;

3549

strcpy(pager, pager_name);

3550

strcpy(default_pager, pager_name);

3637

3551

}

3638

3552

opt_nopager=0;

3639

tee_fprintf(stdout, _("PAGER set to '%s'\n"), pager.c_str());

3553

tee_fprintf(stdout, "PAGER set to '%s'\n", pager);

3640

3554

return 0;

3641

3555

}

3642

3556

3644

3558

static int

3645

3559

com_nopager(string *, const char *)

3646

3560

{

3647

pager.assign("stdout");

3561

strcpy(pager, "stdout");

3648

3562

opt_nopager=1;

3649

3563

PAGER= stdout;

3650

tee_fprintf(stdout, _("PAGER set to stdout\n"));

3564

tee_fprintf(stdout, "PAGER set to stdout\n");

3651

3565

return 0;

3652

3566

}

3653

3567

3657

3571

com_quit(string *, const char *)

3658

3572

{

3659

3573

/* let the screen auto close on a normal shutdown */

3660

status.setExitStatus(0);

3574

status.exit_status=0;

3661

3575

return 1;

3662

3576

}

3663

3577

3705

3619

tmp= get_arg(buff, 0);

3706

3620

if (tmp && *tmp)

3707

3621

{

3708

current_db.erase();

3709

current_db.assign(tmp);

3622

free(current_db);

3623

current_db= strdup(tmp);

3710

3624

tmp= get_arg(buff, 1);

3711

3625

if (tmp)

3712

3626

{

3713

current_host.erase();

3627

free(current_host);

3714

3628

current_host=strdup(tmp);

3715

3629

}

3716

3630

}

3725

3639

}

3726

3640

else

3727

3641

opt_rehash= 0;

3728

error=sql_connect(current_host, current_db, current_user, opt_password,0);

3642

error=sql_connect(current_host,current_db,current_user,opt_password,0);

3729

3643

opt_rehash= save_rehash;

3730

3644

3731

3645

if (connected)

3732

3646

{

3733

sprintf(buff, _("Connection id: %u"), drizzle_con_thread_id(&con));

3647

sprintf(buff,"Connection id: %u",drizzle_con_thread_id(&con));

3734

3648

put_info(buff,INFO_INFO,0,0);

3735

sprintf(buff, _("Current database: %.128s\n"),

3736

!current_db.empty() ? current_db.c_str() : _("*** NONE ***"));

3649

sprintf(buff,"Current database: %.128s\n",

3650

current_db ? current_db : "*** NONE ***");

3737

3651

put_info(buff,INFO_INFO,0,0);

3738

3652

}

3739

3653

return error;

3746

3660

const char *param;

3747

3661

LineBuffer *line_buff;

3748

3662

int error;

3749

Status old_status;

3663

STATUS old_status;

3750

3664

FILE *sql_file;

3751

3665

3752

3666

/* Skip space from file name */

3753

while (isspace(*line))

3667

while (my_isspace(charset_info,*line))

3754

3668

line++;

3755

3669

if (!(param = strchr(line, ' '))) // Skip command name

3756

return put_info(_("Usage: \\. <filename> | source <filename>"),

3670

return put_info("Usage: \\. <filename> | source <filename>",

3757

3671

INFO_ERROR, 0,0);

3758

while (isspace(*param))

3672

while (my_isspace(charset_info,*param))

3759

3673

param++;

3760

3674

end= strncpy(source_name,param,sizeof(source_name)-1);

3761

3675

end+= strlen(source_name);

3762

while (end > source_name && (isspace(end[-1]) ||

3763

iscntrl(end[-1])))

3676

while (end > source_name && (my_isspace(charset_info,end[-1]) ||

3677

my_iscntrl(charset_info,end[-1])))

3764

3678

end--;

3765

3679

end[0]=0;

3766

3680

unpack_filename(source_name,source_name);

3767

3681

/* open file name */

3768

3682

if (!(sql_file = fopen(source_name, "r")))

3769

3683

{

3770

3684

char buff[FN_REFLEN+60];

3771

sprintf(buff, _("Failed to open file '%s', error: %d"), source_name,errno);

3685

sprintf(buff,"Failed to open file '%s', error: %d", source_name,errno);

3772

3686

return put_info(buff, INFO_ERROR, 0 ,0);

3773

3687

}

3774

3688

3776

3690

if (line_buff == NULL)

3777

3691

{

3778

3692

fclose(sql_file);

3779

return put_info(_("Can't initialize LineBuffer"), INFO_ERROR, 0, 0);

3693

return put_info("Can't initialize LineBuffer", INFO_ERROR, 0, 0);

3780

3694

}

3781

3695

3782

3696

/* Save old status */

3784

3698

memset(&status, 0, sizeof(status));

3785

3699

3786

3700

// Run in batch mode

3787

status.setBatch(old_status.getBatch());

3788

status.setLineBuff(line_buff);

3789

status.setFileName(source_name);

3701

status.batch=old_status.batch;

3702

status.line_buff=line_buff;

3703

status.file_name=source_name;

3790

3704

// Empty command buffer

3791

3705

assert(glob_buffer!=NULL);

3792

3706

glob_buffer->clear();

3794

3708

// Continue as before

3795

3709

status=old_status;

3796

3710

fclose(sql_file);

3797

delete status.getLineBuff();

3798

line_buff=0;

3799

status.setLineBuff(0);

3711

delete status.line_buff;

3712

line_buff= status.line_buff= 0;

3800

3713

return error;

3801

3714

}

3802

3715

3812

3725

3813

3726

if (!tmp || !*tmp)

3814

3727

{

3815

put_info(_("DELIMITER must be followed by a 'delimiter' character or string"),

3728

put_info("DELIMITER must be followed by a 'delimiter' character or string",

3816

3729

INFO_ERROR, 0, 0);

3817

3730

return 0;

3818

3731

}

3820

3733

{

3821

3734

if (strstr(tmp, "\\"))

3822

3735

{

3823

put_info(_("DELIMITER cannot contain a backslash character"),

3736

put_info("DELIMITER cannot contain a backslash character",

3824

3737

INFO_ERROR, 0, 0);

3825

3738

return 0;

3826

3739

}

3845

3758

tmp= get_arg(buff, 0);

3846

3759

if (!tmp || !*tmp)

3847

3760

{

3848

put_info(_("USE must be followed by a database name"), INFO_ERROR, 0, 0);

3761

put_info("USE must be followed by a database name", INFO_ERROR, 0, 0);

3849

3762

return 0;

3850

3763

}

3851

3764

3855

3768

3856

3769

get_current_db();

3857

3770

3858

if (current_db.empty() || strcmp(current_db.c_str(),tmp))

3771

if (!current_db || strcmp(current_db,tmp))

3859

3772

{

3860

3773

if (one_database)

3861

3774

{

3907

3820

else

3908

3821

drizzle_result_free(&result);

3909

3822

}

3910

current_db.erase();

3911

current_db.assign(tmp);

3823

free(current_db);

3824

current_db= strdup(tmp);

3912

3825

if (select_db > 1)

3913

3826

build_completion_hash(opt_rehash, 1);

3914

3827

}

3915

3828

3916

put_info(_("Database changed"),INFO_INFO, 0, 0);

3829

put_info("Database changed",INFO_INFO, 0, 0);

3917

3830

return 0;

3918

3831

}

3919

3832

3920

static int com_shutdown(string *, const char *)

3921

{

3922

drizzle_result_st result;

3923

drizzle_return_t ret;

3924

3925

if (verbose)

3926

{

3927

printf(_("shutting down drizzled"));

3928

if (opt_drizzle_port > 0)

3929

printf(_(" on port %d"), opt_drizzle_port);

3930

printf("... ");

3931

}

3932

3933

if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,

3934

&ret) == NULL || ret != DRIZZLE_RETURN_OK)

3935

{

3936

if (ret == DRIZZLE_RETURN_ERROR_CODE)

3937

{

3938

fprintf(stderr, _("shutdown failed; error: '%s'"),

3939

drizzle_result_error(&result));

3940

drizzle_result_free(&result);

3941

}

3942

else

3943

{

3944

fprintf(stderr, _("shutdown failed; error: '%s'"),

3945

drizzle_con_error(&con));

3946

}

3947

return false;

3948

}

3949

3950

drizzle_result_free(&result);

3951

3952

if (verbose)

3953

printf(_("done\n"));

3954

3955

return false;

3956

}

3957

3958

3833

static int

3959

3834

com_warnings(string *, const char *)

3960

3835

{

3961

3836

show_warnings = 1;

3962

put_info(_("Show warnings enabled."),INFO_INFO, 0, 0);

3837

put_info("Show warnings enabled.",INFO_INFO, 0, 0);

3963

3838

return 0;

3964

3839

}

3965

3840

3967

3842

com_nowarnings(string *, const char *)

3968

3843

{

3969

3844

show_warnings = 0;

3970

put_info(_("Show warnings disabled."),INFO_INFO, 0, 0);

3845

put_info("Show warnings disabled.",INFO_INFO, 0, 0);

3971

3846

return 0;

3972

3847

}

3973

3848

3997

3872

else

3998

3873

{

3999

3874

/* skip leading white spaces */

4000

while (isspace(*ptr))

3875

while (my_isspace(charset_info, *ptr))

4001

3876

ptr++;

4002

3877

if (*ptr == '\\') // short command was used

4003

3878

ptr+= 2;

4004

3879

else

4005

while (*ptr &&!isspace(*ptr)) // skip command

3880

while (*ptr &&!my_isspace(charset_info, *ptr)) // skip command

4006

3881

ptr++;

4007

3882

}

4008

3883

if (!*ptr)

4009

3884

return NULL;

4010

while (isspace(*ptr))

3885

while (my_isspace(charset_info, *ptr))

4011

3886

ptr++;

4012

3887

if (*ptr == '\'' || *ptr == '\"' || *ptr == '`')

4013

3888

{

4034

3909

4035

3910

4036

3911

static int

4037

sql_connect(const string &host, const string &database, const string &user, const string &password,

3912

sql_connect(char *host,char *database,char *user,char *password,

4038

3913

uint32_t silent)

4039

3914

{

4040

3915

drizzle_return_t ret;

3916

4041

3917

if (connected)

4042

3918

{

4043

3919

connected= 0;

4045

3921

drizzle_free(&drizzle);

4046

3922

}

4047

3923

drizzle_create(&drizzle);

4048

4049

#ifdef DRIZZLE_ADMIN_TOOL

4050

drizzle_con_options_t options= (drizzle_con_options_t) (DRIZZLE_CON_ADMIN | (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL));

4051

#else

4052

drizzle_con_options_t options= (drizzle_con_options_t) (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);

4053

#endif

4054

4055

if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(),

4056

opt_drizzle_port, (char *)user.c_str(),

4057

(char *)password.c_str(), (char *)database.c_str(),

4058

options) == NULL)

3924

if (drizzle_con_add_tcp(&drizzle, &con, host, opt_drizzle_port, user,

3925

password, database, DRIZZLE_CON_NONE) == NULL)

4059

3926

{

4060

3927

(void) put_error(&con, NULL);

4061

3928

(void) fflush(stdout);

4094

3961

return -1; // Retryable

4095

3962

}

4096

3963

connected=1;

4097

3964

/* XXX hmm?

3965

drizzle.reconnect= debug_info_flag; // We want to know if this happens

3966

4098

3967

build_completion_hash(opt_rehash, 1);

4099

3968

return 0;

4100

3969

}

4111

3980

drizzle_return_t ret;

4112

3981

4113

3982

tee_puts("--------------", stdout);

4114

printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),

4115

drizzle_version(), VERSION,

4116

HOST_VENDOR, HOST_OS, HOST_CPU,

4117

rl_library_version);

4118

3983

usage(1); /* Print version */

4119

3984

if (connected)

4120

3985

{

4121

tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));

3986

tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzle_con_thread_id(&con));

4122

3987

4123

3988

Don't remove "limit 1",

4124

3989

it is protection againts SQL_SELECT_LIMIT=0

4130

3995

drizzle_row_t cur=drizzle_row_next(&result);

4131

3996

if (cur)

4132

3997

{

4133

tee_fprintf(stdout, _("Current database:\t%s\n"), cur[0] ? cur[0] : "");

4134

tee_fprintf(stdout, _("Current user:\t\t%s\n"), cur[1]);

3998

tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");

3999

tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);

4135

4000

}

4136

4001

drizzle_result_free(&result);

4137

4002

}

4138

4003

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

4139

4004

drizzle_result_free(&result);

4140

tee_puts(_("SSL:\t\t\tNot in use"), stdout);

4005

tee_puts("SSL:\t\t\tNot in use", stdout);

4141

4006

}

4142

4007

else

4143

4008

{

4144

4009

vidattr(A_BOLD);

4145

tee_fprintf(stdout, _("\nNo connection\n"));

4010

tee_fprintf(stdout, "\nNo connection\n");

4146

4011

vidattr(A_NORMAL);

4147

4012

return 0;

4148

4013

}

4149

4014

if (skip_updates)

4150

4015

{

4151

4016

vidattr(A_BOLD);

4152

tee_fprintf(stdout, _("\nAll updates ignored to this database\n"));

4017

tee_fprintf(stdout, "\nAll updates ignored to this database\n");

4153

4018

vidattr(A_NORMAL);

4154

4019

}

4155

tee_fprintf(stdout, _("Current pager:\t\t%s\n"), pager.c_str());

4156

tee_fprintf(stdout, _("Using outfile:\t\t'%s'\n"), opt_outfile ? outfile.c_str() : "");

4157

tee_fprintf(stdout, _("Using delimiter:\t%s\n"), delimiter);

4158

tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(&con));

4159

tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());

4160

tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));

4161

tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));

4020

tee_fprintf(stdout, "Current pager:\t\t%s\n", pager);

4021

tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile : "");

4022

tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);

4023

tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&con));

4024

tee_fprintf(stdout, "Protocol version:\t%d\n", drizzle_con_protocol_version(&con));

4025

tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_con_host(&con));

4162

4026

/* XXX need to save this from result

4163

4027

if ((id= drizzleclient_insert_id(&drizzle)))

4164

tee_fprintf(stdout, "Insert id:\t\t%s\n", internal::llstr(id, buff));

4028

tee_fprintf(stdout, "Insert id:\t\t%s\n", llstr(id, buff));

4165

4029

4166

4030

4167

if (drizzle_con_uds(&con))

4168

tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));

4031

if (strcmp(drizzle_con_uds(&con), ""))

4032

tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle_con_uds(&con));

4169

4033

else

4170

tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));

4034

tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle_con_port(&con));

4171

4035

4172

4036

if (safe_updates)

4173

4037

{

4174

4038

vidattr(A_BOLD);

4175

tee_fprintf(stdout, _("\nNote that you are running in safe_update_mode:\n"));

4039

tee_fprintf(stdout, "\nNote that you are running in safe_update_mode:\n");

4176

4040

vidattr(A_NORMAL);

4177

tee_fprintf(stdout, _("\

4041

tee_fprintf(stdout, "\

4178

4042

UPDATEs and DELETEs that don't use a key in the WHERE clause are not allowed.\n\

4179

4043

(One can force an UPDATE/DELETE by adding LIMIT # at the end of the command.)\n \

4180

4044

SELECT has an automatic 'LIMIT %lu' if LIMIT is not used.\n \

4181

Max number of examined row combination in a join is set to: %lu\n\n"),

4045

Max number of examined row combination in a join is set to: %lu\n\n",

4182

4046

select_limit, max_join_size);

4183

4047

}

4184

4048

tee_puts("--------------\n", stdout);

4231

4095

FILE *file= (info_type == INFO_ERROR ? stderr : stdout);

4232

4096

static int inited=0;

4233

4097

4234

if (status.getBatch())

4098

if (status.batch)

4235

4099

{

4236

4100

if (info_type == INFO_ERROR)

4237

4101

{

4238

4102

(void) fflush(file);

4239

fprintf(file,_("ERROR"));

4103

fprintf(file,"ERROR");

4240

4104

if (error)

4241

4105

{

4242

4106

if (sqlstate)

4244

4108

else

4245

4109

(void) fprintf(file," %d",error);

4246

4110

}

4247

if (status.getQueryStartLine() && line_numbers)

4111

if (status.query_start_line && line_numbers)

4248

4112

{

4249

(void) fprintf(file," at line %"PRIu32,status.getQueryStartLine());

4250

if (status.getFileName())

4251

(void) fprintf(file," in file: '%s'", status.getFileName());

4113

(void) fprintf(file," at line %"PRIu32,status.query_start_line);

4114

if (status.file_name)

4115

(void) fprintf(file," in file: '%s'", status.file_name);

4252

4116

}

4253

4117

(void) fprintf(file,": %s\n",str);

4254

4118

(void) fflush(file);

4279

4143

if (error)

4280

4144

{

4281

4145

if (sqlstate)

4282

(void) tee_fprintf(file, _("ERROR %d (%s): "), error, sqlstate);

4146

(void) tee_fprintf(file, "ERROR %d (%s): ", error, sqlstate);

4283

4147

else

4284

(void) tee_fprintf(file, _("ERROR %d: "), error);

4148

(void) tee_fprintf(file, "ERROR %d: ", error);

4285

4149

}

4286

4150

else

4287

tee_puts(_("ERROR: "), file);

4151

tee_puts("ERROR: ", file);

4288

4152

}

4289

4153

else

4290

4154

vidattr(A_BOLD);

4323

4187

{

4324

4188

const char *start= buffer->c_str();

4325

4189

const char *end= start + (buffer->length());

4326

while (start < end && !isgraph(end[-1]))

4190

while (start < end && !my_isgraph(charset_info,end[-1]))

4327

4191

end--;

4328

4192

uint32_t pos_to_truncate= (end-start);

4329

4193

if (buffer->length() > pos_to_truncate)

4417

4281

tmp_buff_str << tmp;

4418

4282

4419

4283

if (tmp > 1)

4420

tmp_buff_str << _(" hours ");

4284

tmp_buff_str << " hours ";

4421

4285

else

4422

tmp_buff_str << _(" hour ");

4286

tmp_buff_str << " hour ";

4423

4287

}

4424

4288

if (sec >= 60.0)

4425

4289

{

4426

4290

tmp=(uint32_t) floor(sec/60.0);

4427

4291

sec-=60.0*tmp;

4428

tmp_buff_str << tmp << _(" min ");

4292

tmp_buff_str << tmp << " min ";

4429

4293

}

4430

4294

if (part_second)

4431

4295

tmp_buff_str.precision(2);

4432

4296

else

4433

4297

tmp_buff_str.precision(0);

4434

tmp_buff_str << sec << _(" sec");

4298

tmp_buff_str << sec << " sec";

4435

4299

strcpy(buff, tmp_buff_str.str().c_str());

4436

4300

}

4437

4301

4462

4326

struct tm *t = localtime(&lclock);

4463

4327

4464

4328

/* parse thru the settings for the prompt */

4465

string::iterator c= current_prompt.begin();

4466

while (c != current_prompt.end())

4329

for (char *c= current_prompt; *c; (void)*c++)

4467

4330

{

4468

4331

if (*c != PROMPT_CHAR)

4469

4332

{

4470

processed_prompt->push_back(*c);

4333

processed_prompt->append(c, 1);

4471

4334

}

4472

4335

else

4473

4336

{

4478

4341

switch (*++c) {

4479

4342

case '\0':

4480

4343

// stop it from going beyond if ends with %

4481

--c;

4344

c--;

4482

4345

break;

4483

4346

case 'c':

4484

4347

add_int_to_prompt(++prompt_counter);

4490

4353

processed_prompt->append("not_connected");

4491

4354

break;

4492

4355

case 'd':

4493

processed_prompt->append(not current_db.empty() ? current_db : "(none)");

4356

processed_prompt->append(current_db ? current_db : "(none)");

4494

4357

break;

4495

4358

case 'h':

4496

4359

{

4497

const char *prompt= connected ? drizzle_con_host(&con) : "not_connected";

4360

const char *prompt;

4361

prompt= connected ? drizzle_con_host(&con) : "not_connected";

4498

4362

if (strstr(prompt, "Localhost"))

4499

4363

processed_prompt->append("localhost");

4500

4364

else

4513

4377

break;

4514

4378

}

4515

4379

4516

if (drizzle_con_uds(&con))

4380

if (strcmp(drizzle_con_uds(&con), ""))

4517

4381

{

4518

4382

const char *pos=strrchr(drizzle_con_uds(&con),'/');

4519

4383

processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));

4526

4390

if (!full_username)

4527

4391

init_username();

4528

4392

processed_prompt->append(full_username ? full_username :

4529

(!current_user.empty() ? current_user : "(unknown)"));

4393

(current_user ? current_user : "(unknown)"));

4530

4394

break;

4531

4395

case 'u':

4532

4396

if (!full_username)

4533

4397

init_username();

4534

4398

processed_prompt->append(part_username ? part_username :

4535

(!current_user.empty() ? current_user : _("(unknown)")));

4399

(current_user ? current_user : "(unknown)"));

4536

4400

break;

4537

4401

case PROMPT_CHAR:

4538

4402

{

4614

4478

processed_prompt->append(delimiter_str);

4615

4479

break;

4616

4480

default:

4617

processed_prompt->push_back(*c);

4481

processed_prompt->append(c, 1);

4618

4482

}

4619

4483

}

4620

++c;

4621

4484

}

4622

4485

return processed_prompt->c_str();

4623

4486

}

4652

4515

{

4653

4516

const char *ptr=strchr(line, ' ');

4654

4517

if (ptr == NULL)

4655

tee_fprintf(stdout, _("Returning to default PROMPT of %s\n"),

4518

tee_fprintf(stdout, "Returning to default PROMPT of %s\n",

4656

4519

default_prompt);

4657

4520

prompt_counter = 0;

4658

4521

char * tmpptr= strdup(ptr ? ptr+1 : default_prompt);

4659

4522

if (tmpptr == NULL)

4660

tee_fprintf(stdout, _("Memory allocation error. Not changing prompt\n"));

4523

tee_fprintf(stdout, "Memory allocation error. Not changing prompt\n");

4661

4524

else

4662

4525

{

4663

current_prompt.erase();

4526

free(current_prompt);

4664

4527

current_prompt= tmpptr;

4665

tee_fprintf(stdout, _("PROMPT set to '%s'\n"), current_prompt.c_str());

4528

tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt);

4666

4529

}

4667

4530

return 0;

4668

4531

}

Older »