static void do_log_sense(int fd)
{
unsigned char cdb[32];
unsigned char buf[16*1024];
unsigned cdb_len = cdb_log_sense(cdb, 0, 0, sizeof(buf));
int buf_len;
buf_len = simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
if (buf_len < 0) {
printf("error while reading log sense list, nothing to show\n");
return;
}
if (!log_sense_is_valid(buf, buf_len)) {
printf("log sense page is invalid\n");
return;
}
if (buf[0] != 0 || buf[1] != 0) {
printf("expected to receive log page 0 subpage 0\n");
return;
}
uint16_t num_pages = get_uint16(buf, 2);
uint16_t i;
for (i = 0; i < num_pages; i++) {
dump_log_sense(fd, buf[4 + i], 0);
}
cdb_len = cdb_log_sense(cdb, 0, 0xff, sizeof(buf));
buf_len = simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
if (buf_len < 0) {
printf("error while reading list of log subpages, nothing to show\n");
return;
}
if (!log_sense_is_valid(buf, buf_len)) {
printf("log sense list must have at least 4 bytes\n");
return;
}
if (buf[0] != 0x40 || buf[1] != 0xFF) {
printf("expected to receive log page 0 (spf=1) subpage 0xFF\n");
return;
}
num_pages = get_uint16(buf, 2);
for (i = 0; i < num_pages; i++) {
uint8_t page = buf[4 + i*2] & 0x3F;
uint8_t subpage = buf[4 + i*2 + 1];
if (subpage == 0) {
printf("Skipping page %02X subpage %02X since subpage is 00 it was already retrieved above\n", page, subpage);
continue;
}
dump_log_sense(fd, page, subpage);
}
}
INT64_T chirp_client_fstatfs(struct chirp_client * c, INT64_T fd, struct chirp_statfs * info, time_t stoptime)
{
INT64_T result = simple_command(c, stoptime, "fstatfs %lld\n", fd);
if(result >= 0)
result = get_statfs_result(c, info, stoptime);
return result;
}
INT64_T chirp_client_audit(struct chirp_client * c, const char *path, struct chirp_audit ** list, time_t stoptime)
{
INT64_T result;
struct chirp_audit *entry;
int i, actual;
char line[CHIRP_LINE_MAX];
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
result = simple_command(c, stoptime, "audit %s\n", safepath);
if(result <= 0)
return result;
*list = malloc(sizeof(struct chirp_audit) * result);
entry = *list;
for(i = 0; i < result; i++) {
actual = link_readline(c->link, line, sizeof(line), stoptime);
if(actual <= 0) {
free(*list);
result = -1;
errno = ECONNRESET;
break;
} else {
sscanf(line, "%s %" SCNd64 " %" SCNd64 " %" SCNd64 , entry->name, &entry->nfiles, &entry->ndirs, &entry->nbytes);
}
entry++;
}
return result;
}
CHIRP_SEARCH *chirp_client_opensearch(struct chirp_client *c, const char *path, const char *pattern, int flags, time_t stoptime) {
INT64_T result = simple_command(c, stoptime, "search %s %s %d\n", pattern, path, flags);
char p[CHIRP_PATH_MAX];
size_t buffer_size = 2048;
char *buffer = malloc(buffer_size);
size_t l, i=0;
if (result == 0) {
while (link_readline(c->link, p, sizeof(p), stoptime)) {
if (strcmp(p, "") == 0) break;
while ((l = (size_t)snprintf(buffer+i, buffer_size-i, p)) >= buffer_size-i) {
buffer_size *= 2;
char *rbuffer = (char*) realloc(buffer, buffer_size);
if (rbuffer==NULL) return NULL;
buffer = rbuffer;
}
i += l;
}
if (i==0) *buffer = '\0';
CHIRP_SEARCH *result = malloc(sizeof(CHIRP_SEARCH));
result->entry = (struct chirp_searchent*) malloc(sizeof(struct chirp_searchent));
result->entry->info = NULL;
result->entry->path = NULL;
result->data = buffer;
result->i = 0;
return result;
} else
return NULL;
}
INT64_T chirp_client_getlongdir(struct chirp_client * c, const char *path, chirp_longdir_t callback, void *arg, time_t stoptime)
{
char name[CHIRP_LINE_MAX];
struct chirp_stat info;
int result;
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
result = simple_command(c, stoptime, "getlongdir %s\n", safepath);
if(result < 0)
return result;
while(link_readline(c->link, name, sizeof(name), stoptime)) {
if(!name[0])
return 0;
if(get_stat_result(c, &info, stoptime) >= 0) {
callback(name, &info, arg);
} else {
break;
}
}
c->broken = 1;
errno = ECONNRESET;
return -1;
}
INT64_T chirp_client_openacl(struct chirp_client * c, const char *path, time_t stoptime)
{
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
return simple_command(c, stoptime, "getacl %s\n", safepath);
}
static void do_receive_diagnostic(int fd)
{
unsigned char cdb[32];
unsigned char buf[16*1024];
unsigned cdb_len = cdb_receive_diagnostics(cdb, true, 0, sizeof(buf));
int buf_len;
buf_len = simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
if (buf_len < 0) {
printf("error while reading response buffer, nothing to show\n");
return;
}
if (recv_diag_is_valid(buf, buf_len)) {
printf("receive diagnostics list must have at least 4 bytes\n");
return;
}
if (recv_diag_get_page_code(buf) != 0) {
printf("expected to receive receive diagnostics page 0\n");
return;
}
uint16_t num_pages = recv_diag_get_len(buf);
uint16_t i;
for (i = 0; i < num_pages; i++) {
dump_rcv_diag_page(fd, buf[4 + i]);
}
}
INT64_T chirp_client_getfile_buffer(struct chirp_client * c, const char *path, char **buffer, time_t stoptime)
{
INT64_T length;
INT64_T result;
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
*buffer = 0;
length = simple_command(c, stoptime, "getfile %s\n", safepath);
if(length <= 0)
return length;
*buffer = malloc(length + 1);
if(!*buffer) {
c->broken = 1;
errno = ENOMEM;
return -1;
}
result = link_read(c->link, *buffer, length, stoptime);
if(result < 0) {
free(*buffer);
c->broken = 1;
return -1;
}
(*buffer)[length] = 0;
return result;
}
static int do_ata_smart_read_log_addr(int fd, unsigned char *buf, unsigned buf_sz, uint8_t log_addr, uint8_t block_count)
{
uint8_t cdb[32];
int cdb_len;
cdb_len = cdb_ata_smart_read_log(cdb, log_addr, block_count);
return simple_command(fd, cdb, cdb_len, buf, buf_sz);
}
static int do_ata_read_log_ext_page(int fd, uint8_t *buf, unsigned buf_sz, unsigned log_addr, unsigned page)
{
uint8_t cdb[32];
int cdb_len;
cdb_len = cdb_ata_read_log_ext(cdb, 1, page, log_addr);
return simple_command(fd, cdb, cdb_len, buf, buf_sz);
}
static void do_read_defect_data_12(int fd, bool plist, bool glist, uint8_t format, bool count_only)
{
unsigned char cdb[32];
unsigned char buf[512];
unsigned cdb_len = cdb_read_defect_data_12(cdb, plist, glist, format, count_only ? 8 : sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void do_read_capacity_16(int fd)
{
unsigned char cdb[32];
unsigned char buf[512];
unsigned cdb_len = cdb_read_capacity_16(cdb, sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void dump_rcv_diag_page(int fd, uint8_t page)
{
unsigned char cdb[32];
unsigned char buf[16*1024];
unsigned cdb_len = cdb_receive_diagnostics(cdb, true, page, sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void do_mode_sense_6_type(int fd, bool disable_block_desc, page_control_e page_control)
{
unsigned char cdb[32];
unsigned char buf[255];
unsigned cdb_len = cdb_mode_sense_6(cdb, disable_block_desc, page_control, 0x3F, 0xFF, sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void dump_log_sense(int fd, uint8_t page, uint8_t subpage)
{
unsigned char cdb[32];
unsigned char buf[16*1024];
unsigned cdb_len = cdb_log_sense(cdb, page, subpage, sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void dump_evpd(int fd, uint8_t evpd_page)
{
unsigned char cdb[32];
unsigned char buf[512];
unsigned cdb_len = cdb_inquiry(cdb, true, evpd_page, sizeof(buf));
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
INT64_T chirp_client_lremovexattr(struct chirp_client *c, const char *path, const char *name, time_t stoptime)
{
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
INT64_T result = simple_command(c, stoptime, "lremovexattr %s %s\n", safepath, name);
if (result == -1 && errno == EINVAL) errno = ENOATTR;
return result;
}
INT64_T chirp_client_statfs(struct chirp_client * c, const char *path, struct chirp_statfs * info, time_t stoptime)
{
char safepath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
INT64_T result = simple_command(c, stoptime, "statfs %s\n", safepath);
if(result >= 0)
result = get_statfs_result(c, info, stoptime);
return result;
}
static void do_ata_check_power_mode(int fd)
{
uint8_t cdb[32];
int cdb_len;
printf("Check power mode\n");
cdb_len = cdb_ata_check_power_mode(cdb);
simple_command(fd, cdb, cdb_len, NULL, 0);
}
static void do_ata_identify_16(int fd)
{
uint8_t cdb[32];
int cdb_len;
uint8_t buf[512];
cdb_len = cdb_ata_identify_16(cdb);
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
static void do_ata_smart_read_threshold(int fd)
{
uint8_t cdb[32];
int cdb_len;
uint8_t buf[512];
cdb_len = cdb_ata_smart_read_threshold(cdb);
simple_command(fd, cdb, cdb_len, buf, sizeof(buf));
}
INT64_T chirp_client_link(struct chirp_client * c, const char *oldpath, const char *newpath, time_t stoptime)
{
char safeoldpath[CHIRP_LINE_MAX];
char safenewpath[CHIRP_LINE_MAX];
url_encode(oldpath, safeoldpath, sizeof(safeoldpath));
url_encode(newpath, safenewpath, sizeof(safenewpath));
return simple_command(c, stoptime, "link %s %s\n", safeoldpath, safenewpath);
}
INT64_T chirp_client_thirdput(struct chirp_client * c, const char *path, const char *hostname, const char *newpath, time_t stoptime)
{
char safepath[CHIRP_LINE_MAX];
char safenewpath[CHIRP_LINE_MAX];
url_encode(path, safepath, sizeof(safepath));
url_encode(newpath, safenewpath, sizeof(safenewpath));
return simple_command(c, stoptime, "thirdput %s %s %s\n", safepath, hostname, safenewpath);
}
my_bool vt_simple_command(
VT_CONN *conn,
enum enum_server_command command,
const unsigned char *arg,
unsigned long arg_length,
my_bool skip_check)
{
mysql_thread_init();
return simple_command(conn->mysql, command, arg, arg_length, skip_check);
}
static int send_change_user_packet(MCPVIO_EXT *mpvio,
const uchar *data, int data_len)
{
MYSQL *mysql= mpvio->mysql;
char *buff, *end;
int res= 1;
size_t conn_attr_len= (mysql->options.extension) ?
mysql->options.extension->connect_attrs_len : 0;
buff= my_alloca(USERNAME_LENGTH+1 + data_len+1 + NAME_LEN+1 + 2 + NAME_LEN+1 + 9 + conn_attr_len);
end= strmake(buff, mysql->user, USERNAME_LENGTH) + 1;
if (!data_len)
*end++= 0;
else
{
if (mysql->client_flag & CLIENT_SECURE_CONNECTION)
{
DBUG_ASSERT(data_len <= 255);
if (data_len > 255)
{
my_set_error(mysql, CR_MALFORMED_PACKET, SQLSTATE_UNKNOWN, 0);
goto error;
}
*end++= data_len;
}
else
{
DBUG_ASSERT(data_len == SCRAMBLE_LENGTH_323 + 1);
DBUG_ASSERT(data[SCRAMBLE_LENGTH_323] == 0);
}
memcpy(end, data, data_len);
end+= data_len;
}
end= strmake(end, mpvio->db ? mpvio->db : "", NAME_LEN) + 1;
if (mysql->server_capabilities & CLIENT_PROTOCOL_41)
{
int2store(end, (ushort) mysql->charset->nr);
end+= 2;
}
if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
end= strmake(end, mpvio->plugin->name, NAME_LEN) + 1;
end= ma_send_connect_attr(mysql, end);
res= simple_command(mysql, MYSQL_COM_CHANGE_USER,
buff, (ulong)(end-buff), 1, NULL);
error:
my_afree(buff);
return res;
}
DLLEXPORT int
chirp_client_whoami( struct chirp_client *c, char *buffer, int length) {
int result, actual;
result = simple_command(c, "whoami %d\n", length);
if(result > 0) {
actual = fread(buffer,1,result,c->rstream);
if(actual!=result) chirp_fatal_request("whoami");
}
return result;
}
/*
Altough mysql_create_db(), mysql_rm_db() are deprecated since 4.0 they
should not crash server and should not hang in case of errors.
Since those functions can't be seen in modern API (unless client library
was compiled with USE_OLD_FUNCTIONS define) we use simple_command() macro.
*/
static int test_bug6081(MYSQL *mysql)
{
int rc;
if (mysql_get_server_version(mysql) < 50100) {
diag("Test requires MySQL Server version 5.1 or above");
return SKIP;
}
rc= simple_command(mysql, MYSQL_COM_DROP_DB, (char*) schema,
(ulong)strlen(schema), 0U);
FAIL_IF(!rc, "Error expected");
rc= simple_command(mysql, MYSQL_COM_CREATE_DB, (char*) schema,
(ulong)strlen(schema), 0U);
FAIL_IF(!rc, "Error expected");
rc= mysql_select_db(mysql, schema);
check_mysql_rc(rc, mysql);
return OK;
}
INT64_T chirp_client_ticket_delete(struct chirp_client * c, const char *name, time_t stoptime)
{
char ticket_subject[CHIRP_LINE_MAX];
ticket_translate(name, ticket_subject);
INT64_T result = simple_command(c, stoptime, "ticket_delete %s\n", ticket_subject);
if(result == 0) {
unlink(name);
}
return result;
}
DLLEXPORT int
chirp_client_readlink( struct chirp_client *c, const char *path, int length,
char **buffer )
{
int result, actual;
result = simple_command(c,"readlink %s %d\n",path, length);
if(result > 0) {
*buffer = (char*)malloc(result);
actual = fread(*buffer,1,result,c->rstream);
if(actual!=result) chirp_fatal_request("readlink");
}
return result;
}
DLLEXPORT int
chirp_client_read( struct chirp_client *c, int fd, void *buffer, int length )
{
int result;
int actual;
result = simple_command(c,"read %d %d\n",fd,length);
if( result>0 ) {
actual = fread(buffer,1,result,c->rstream);
if(actual!=result) chirp_fatal_request("read");
}
return result;
}
