~zulcss/samba/server-dailies-3.4

{"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE,COMPL_NONE}},

3909

{"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},

3910

{"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},

3911

{"case_sensitive",cmd_setcase,"toggle the case sensitive flag to server",{COMPL_NONE,COMPL_NONE}},

3912

{"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},

3913

{"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},

3914

{"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},

3915

{"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_REMOTE}},

3916

{"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},

3917

{"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},

3918

{"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},

3919

{"echo",cmd_echo,"ping the server",{COMPL_NONE,COMPL_NONE}},

3920

{"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},

3921

{"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},

3922

{"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_LOCAL}},

3923

{"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},

3924

{"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},

3925

{"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},

3926

{"iosize",cmd_iosize,"iosize <number> (default 64512)",{COMPL_NONE,COMPL_NONE}},

3927

{"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},

3928

{"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},

3929

{"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},

3930

{"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},

3931

{"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},

3932

{"l",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},

3933

{"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},

3934

{"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},

3935

{"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},

3936

{"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},

3937

{"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},

3938

{"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},

3939

{"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},

3940

{"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},

3941

{"posix", cmd_posix, "turn on all POSIX capabilities", {COMPL_REMOTE,COMPL_NONE}},

3942

{"posix_encrypt",cmd_posix_encrypt,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE,COMPL_NONE}},

3943

{"posix_open",cmd_posix_open,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},

3944

{"posix_mkdir",cmd_posix_mkdir,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},

3945

{"posix_rmdir",cmd_posix_rmdir,"<name> removes a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},

3946

{"posix_unlink",cmd_posix_unlink,"<name> removes a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},

3947

{"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},

3948

{"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},

3949

{"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},

3950

{"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},

3951

{"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},

3952

{"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}},

3953

{"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},

3954

{"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},

3955

{"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},

3956

{"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},

3957

{"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},

3958

{"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},

3959

{"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},

3960

{"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},

3961

{"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},

3962

{"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},

3963

{"stat",cmd_stat,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_REMOTE}},

3964

{"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},

3965

{"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},

3966

{"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},

3967

{"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},

3968

{"unlock",cmd_unlock,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},

3969

{"volume",cmd_volume,"print the volume name",{COMPL_NONE,COMPL_NONE}},

3970

{"vuid",cmd_vuid,"change current vuid",{COMPL_NONE,COMPL_NONE}},

3971

{"wdel",cmd_wdel,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE,COMPL_NONE}},

3972

{"logon",cmd_logon,"establish new logon",{COMPL_NONE,COMPL_NONE}},

3973

{"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},

3974

{"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},

3975

{"..",cmd_cd_oneup,"change the remote directory (up one level)",{COMPL_REMOTE,COMPL_NONE}},

3976

3977

/* Yes, this must be here, see crh's comment above. */

3978

{"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},

3979

{NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}

3980

};

3981

3982

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

3983

Lookup a command string in the list of commands, including

3984

abbreviations.

3985

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

3986

3987

static int process_tok(char *tok)

3988

{

3989

int i = 0, matches = 0;

3990

int cmd=0;

3991

int tok_len = strlen(tok);

3992

3993

while (commands[i].fn != NULL) {

3994

if (strequal(commands[i].name,tok)) {

3995

matches = 1;

3996

cmd = i;

3997

break;

3998

} else if (strnequal(commands[i].name, tok, tok_len)) {

3999

matches++;

4000

cmd = i;

4001

}

4002

i++;

4003

}

4004

4005

if (matches == 0)

4006

return(-1);

4007

else if (matches == 1)

4008

return(cmd);

4009

else

4010

return(-2);

4011

}

4012

4013

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

4014

Help.

4015

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

4016

4017

static int cmd_help(void)

4018

{

4019

TALLOC_CTX *ctx = talloc_tos();

4020

int i=0,j;

4021

char *buf;

4022

4023

if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {

4024

if ((i = process_tok(buf)) >= 0)

4025

d_printf("HELP %s:\n\t%s\n\n",

4026

commands[i].name,commands[i].description);

4027

} else {

4028

while (commands[i].description) {

4029

for (j=0; commands[i].description && (j<5); j++) {

4030

d_printf("%-15s",commands[i].name);

4031

i++;

4032

}

4033

d_printf("\n");

4034

}

4035

}

4036

return 0;

4037

}

4038

4039

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

4040

Process a -c command string.

4041

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

4042

4043

static int process_command_string(const char *cmd_in)

4044

{

4045

TALLOC_CTX *ctx = talloc_tos();

4046

char *cmd = talloc_strdup(ctx, cmd_in);

4047

int rc = 0;

4048

4049

if (!cmd) {

4050

return 1;

4051

}

4052

/* establish the connection if not already */

4053

4054

if (!cli) {

4055

cli = cli_cm_open(talloc_tos(), NULL,

4056

have_ip ? dest_ss_str : desthost,

4057

service, auth_info,

4058

true, smb_encrypt,

4059

max_protocol, port, name_type);

4060

if (!cli) {

4061

return 1;

4062

}

4063

}

4064

4065

while (cmd[0] != '\0') {

4066

char *line;

4067

char *p;

4068

char *tok;

4069

int i;

4070

4071

if ((p = strchr_m(cmd, ';')) == 0) {

4072

line = cmd;

4073

cmd += strlen(cmd);

4074

} else {

4075

*p = '\0';

4076

line = cmd;

4077

cmd = p + 1;

4078

}

4079

4080

/* and get the first part of the command */

4081

cmd_ptr = line;

4082

if (!next_token_talloc(ctx, &cmd_ptr,&tok,NULL)) {

4083

continue;

4084

}

4085

4086

if ((i = process_tok(tok)) >= 0) {

4087

rc = commands[i].fn();

4088

} else if (i == -2) {

4089

d_printf("%s: command abbreviation ambiguous\n",tok);

4090

} else {

4091

d_printf("%s: command not found\n",tok);

4092

}

4093

}

4094

4095

return rc;

4096

}

4097

4098

#define MAX_COMPLETIONS 100

4099

4100

typedef struct {

4101

char *dirmask;

4102

char **matches;

4103

int count, samelen;

4104

const char *text;

4105

int len;

4106

} completion_remote_t;

4107

4108

static void completion_remote_filter(const char *mnt,

4109

file_info *f,

4110

const char *mask,

4111

void *state)

4112

{

4113

completion_remote_t *info = (completion_remote_t *)state;

4114

4115

if ((info->count < MAX_COMPLETIONS - 1) &&

4116

(strncmp(info->text, f->name, info->len) == 0) &&

4117

(strcmp(f->name, ".") != 0) &&

4118

(strcmp(f->name, "..") != 0)) {

4119

if ((info->dirmask[0] == 0) && !(f->mode & aDIR))

4120

info->matches[info->count] = SMB_STRDUP(f->name);

4121

else {

4122

TALLOC_CTX *ctx = talloc_stackframe();

4123

char *tmp;

4124

4125

tmp = talloc_strdup(ctx,info->dirmask);

4126

if (!tmp) {

4127

TALLOC_FREE(ctx);

4128

return;

4129

}

4130

tmp = talloc_asprintf_append(tmp, "%s", f->name);

4131

if (!tmp) {

4132

TALLOC_FREE(ctx);

4133

return;

4134

}

4135

if (f->mode & aDIR) {

4136

tmp = talloc_asprintf_append(tmp, "%s", CLI_DIRSEP_STR);

4137

}

4138

if (!tmp) {

4139

TALLOC_FREE(ctx);

4140

return;

4141

}

4142

info->matches[info->count] = SMB_STRDUP(tmp);

4143

TALLOC_FREE(ctx);

4144

}

4145

if (info->matches[info->count] == NULL) {

4146

return;

4147

}

4148

if (f->mode & aDIR) {

4149

smb_readline_ca_char(0);

4150

}

4151

if (info->count == 1) {

4152

info->samelen = strlen(info->matches[info->count]);

4153

} else {

4154

while (strncmp(info->matches[info->count],

4155

info->matches[info->count-1],

4156

info->samelen) != 0) {

4157

info->samelen--;

4158

}

4159

}

4160

info->count++;

4161

}

4162

}

4163

4164

static char **remote_completion(const char *text, int len)

4165

{

4166

TALLOC_CTX *ctx = talloc_stackframe();

4167

char *dirmask = NULL;

4168

char *targetpath = NULL;

4169

struct cli_state *targetcli = NULL;

4170

int i;

4171

completion_remote_t info = { NULL, NULL, 1, 0, NULL, 0 };

4172

4173

/* can't have non-static intialisation on Sun CC, so do it

4174

at run time here */

4175

info.samelen = len;

4176

info.text = text;

4177

info.len = len;

4178

4179

info.matches = SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS);

4180

if (!info.matches) {

4181

TALLOC_FREE(ctx);

4182

return NULL;

4183

}

4184

4185

4186

* We're leaving matches[0] free to fill it later with the text to

4187

* display: Either the one single match or the longest common subset

4188

* of the matches.

4189

4190

info.matches[0] = NULL;

4191

info.count = 1;

4192

4193

for (i = len-1; i >= 0; i--) {

4194

if ((text[i] == '/') || (text[i] == CLI_DIRSEP_CHAR)) {

4195

break;

4196

}

4197

}

4198

4199

info.text = text+i+1;

4200

info.samelen = info.len = len-i-1;

4201

4202

if (i > 0) {

4203

info.dirmask = SMB_MALLOC_ARRAY(char, i+2);

4204

if (!info.dirmask) {

4205

goto cleanup;

4206

}

4207

strncpy(info.dirmask, text, i+1);

4208

info.dirmask[i+1] = 0;

4209

dirmask = talloc_asprintf(ctx,

4210

"%s%*s*",

4211

client_get_cur_dir(),

4212

i-1,

4213

text);

4214

} else {

4215

info.dirmask = SMB_STRDUP("");

4216

if (!info.dirmask) {

4217

goto cleanup;

4218

}

4219

dirmask = talloc_asprintf(ctx,

4220

"%s*",

4221

client_get_cur_dir());

4222

}

4223

if (!dirmask) {

4224

goto cleanup;

4225

}

4226

4227

if (!cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli, &targetpath)) {

4228

goto cleanup;

4229

}

4230

if (cli_list(targetcli, targetpath, aDIR | aSYSTEM | aHIDDEN,

4231

completion_remote_filter, (void *)&info) < 0) {

4232

goto cleanup;

4233

}

4234

4235

if (info.count == 1) {

4236

4237

* No matches at all, NULL indicates there is nothing

4238

4239

SAFE_FREE(info.matches[0]);

4240

SAFE_FREE(info.matches);

4241

TALLOC_FREE(ctx);

4242

return NULL;

4243

}

4244

4245

if (info.count == 2) {

4246

4247

* Exactly one match in matches[1], indicate this is the one

4248

* in matches[0].

4249

4250

info.matches[0] = info.matches[1];

4251

info.matches[1] = NULL;

4252

info.count -= 1;

4253

TALLOC_FREE(ctx);

4254

return info.matches;

4255

}

4256

4257

4258

* We got more than one possible match, set the result to the maximum

4259

* common subset

4260

4261

4262

info.matches[0] = SMB_STRNDUP(info.matches[1], info.samelen);

4263

info.matches[info.count] = NULL;

4264

return info.matches;

4265

4266

cleanup:

4267

for (i = 0; i < info.count; i++) {

4268

SAFE_FREE(info.matches[i]);

4269

}

4270

SAFE_FREE(info.matches);

4271

SAFE_FREE(info.dirmask);

4272

TALLOC_FREE(ctx);

4273

return NULL;

4274

}

4275

4276

static char **completion_fn(const char *text, int start, int end)

4277

{

4278

smb_readline_ca_char(' ');

4279

4280

if (start) {

4281

const char *buf, *sp;

4282

int i;

4283

char compl_type;

4284

4285

buf = smb_readline_get_line_buffer();

4286

if (buf == NULL)

4287

return NULL;

4288

4289

sp = strchr(buf, ' ');

4290

if (sp == NULL)

4291

return NULL;

4292

4293

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

4294

if ((strncmp(commands[i].name, buf, sp - buf) == 0) &&

4295

(commands[i].name[sp - buf] == 0)) {

4296

break;

4297

}

4298

}

4299

if (commands[i].name == NULL)

4300

return NULL;

4301

4302

while (*sp == ' ')

4303

sp++;

4304

4305

if (sp == (buf + start))

4306

compl_type = commands[i].compl_args[0];

4307

else

4308

compl_type = commands[i].compl_args[1];

4309

4310

if (compl_type == COMPL_REMOTE)

4311

return remote_completion(text, end - start);

4312

else /* fall back to local filename completion */

4313

return NULL;

4314

} else {

4315

char **matches;

4316

int i, len, samelen = 0, count=1;

4317

4318

matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);

4319

if (!matches) {

4320

return NULL;

4321

}

4322

matches[0] = NULL;

4323

4324

len = strlen(text);

4325

for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {

4326

if (strncmp(text, commands[i].name, len) == 0) {

4327

matches[count] = SMB_STRDUP(commands[i].name);

4328

if (!matches[count])

4329

goto cleanup;

4330

if (count == 1)

4331

samelen = strlen(matches[count]);

4332

else

4333

while (strncmp(matches[count], matches[count-1], samelen) != 0)

4334

samelen--;

4335

count++;

4336

}

4337

}

4338

4339

switch (count) {

4340

case 0: /* should never happen */

4341

case 1:

4342

goto cleanup;

4343

case 2:

4344

matches[0] = SMB_STRDUP(matches[1]);

4345

break;

4346

default:

4347

matches[0] = (char *)SMB_MALLOC(samelen+1);

4348

if (!matches[0])

4349

goto cleanup;

4350

strncpy(matches[0], matches[1], samelen);

4351

matches[0][samelen] = 0;

4352

}

4353

matches[count] = NULL;

4354

return matches;

4355

4356

cleanup:

4357

for (i = 0; i < count; i++)

4358

free(matches[i]);

4359

4360

free(matches);

4361

return NULL;

4362

}

4363

}

4364

4365

static bool finished;

4366

4367

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

4368

Make sure we swallow keepalives during idle time.

4369

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

4370

4371

static void readline_callback(void)

4372

{

4373

fd_set fds;

4374

struct timeval timeout;

4375

static time_t last_t;

4376

time_t t;

4377

4378

t = time(NULL);

4379

4380

if (t - last_t < 5)

4381

return;

4382

4383

last_t = t;

4384

4385

again:

4386

4387

if (cli->fd == -1)

4388

return;

4389

4390

FD_ZERO(&fds);

4391

FD_SET(cli->fd,&fds);

4392

4393

timeout.tv_sec = 0;

4394

timeout.tv_usec = 0;

4395

sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout);

4396

4397

/* We deliberately use receive_smb_raw instead of

4398

client_receive_smb as we want to receive

4399

session keepalives and then drop them here.

4400

4401

if (FD_ISSET(cli->fd,&fds)) {

4402

NTSTATUS status;

4403

size_t len;

4404

4405

set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK);

4406

4407

status = receive_smb_raw(cli->fd, cli->inbuf, cli->bufsize, 0, 0, &len);

4408

4409

if (!NT_STATUS_IS_OK(status)) {

4410

DEBUG(0, ("Read from server failed, maybe it closed "

4411

"the connection\n"));

4412

4413

finished = true;

4414

smb_readline_done();

4415

if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {

4416

set_smb_read_error(&cli->smb_rw_error,

4417

SMB_READ_EOF);

4418

return;

4419

}

4420

4421

if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {

4422

set_smb_read_error(&cli->smb_rw_error,

4423

SMB_READ_TIMEOUT);

4424

return;

4425

}

4426

4427

set_smb_read_error(&cli->smb_rw_error, SMB_READ_ERROR);

4428

return;

4429

}

4430

if(CVAL(cli->inbuf,0) != SMBkeepalive) {

4431

DEBUG(0, ("Read from server "

4432

"returned unexpected packet!\n"));

4433

return;

4434

}

4435

4436

goto again;

4437

}

4438

4439

/* Ping the server to keep the connection alive using SMBecho. */

4440

{

4441

NTSTATUS status;

4442

unsigned char garbage[16];

4443

memset(garbage, 0xf0, sizeof(garbage));

4444

status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));

4445

4446

if (!NT_STATUS_IS_OK(status)) {

4447

DEBUG(0, ("SMBecho failed. Maybe server has closed "

4448

"the connection\n"));

4449

finished = true;

4450

smb_readline_done();

4451

}

4452

}

4453

}

4454

4455

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

4456

Process commands on stdin.

4457

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

4458

4459

static int process_stdin(void)

4460

{

4461

int rc = 0;

4462

4463

while (!finished) {

4464

TALLOC_CTX *frame = talloc_stackframe();

4465

char *tok = NULL;

4466

char *the_prompt = NULL;

4467

char *line = NULL;

4468

int i;

4469

4470

/* display a prompt */

4471

if (asprintf(&the_prompt, "smb: %s> ", client_get_cur_dir()) < 0) {

4472

TALLOC_FREE(frame);

4473

break;

4474

}

4475

line = smb_readline(the_prompt, readline_callback, completion_fn);

4476

SAFE_FREE(the_prompt);

4477

if (!line) {

4478

TALLOC_FREE(frame);

4479

break;

4480

}

4481

4482

/* special case - first char is ! */

4483

if (*line == '!') {

4484

if (system(line + 1) == -1) {

4485

d_printf("system() command %s failed.\n",

4486

line+1);

4487

}

4488

SAFE_FREE(line);

4489

TALLOC_FREE(frame);

4490

continue;

4491

}

4492

4493

/* and get the first part of the command */

4494

cmd_ptr = line;

4495

if (!next_token_talloc(frame, &cmd_ptr,&tok,NULL)) {

4496

TALLOC_FREE(frame);

4497

SAFE_FREE(line);

4498

continue;

4499

}

4500

4501

if ((i = process_tok(tok)) >= 0) {

4502

rc = commands[i].fn();

4503

} else if (i == -2) {

4504

d_printf("%s: command abbreviation ambiguous\n",tok);

4505

} else {

4506

d_printf("%s: command not found\n",tok);

4507

}

4508

SAFE_FREE(line);

4509

TALLOC_FREE(frame);

4510

}

4511

return rc;

4512

}

4513

4514

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

4515

Process commands from the client.

4516

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

4517

4518

static int process(const char *base_directory)

4519

{

4520

int rc = 0;

4521

4522

cli = cli_cm_open(talloc_tos(), NULL,

4523

have_ip ? dest_ss_str : desthost,

4524

service, auth_info, true, smb_encrypt,

4525

max_protocol, port, name_type);

4526

if (!cli) {

4527

return 1;

4528

}

4529

4530

if (base_directory && *base_directory) {

4531

rc = do_cd(base_directory);

4532

if (rc) {

4533

cli_shutdown(cli);

4534

return rc;

4535

}

4536

}

4537

4538

if (cmdstr) {

4539

rc = process_command_string(cmdstr);

4540

} else {

4541

process_stdin();

4542

}

4543

4544

cli_shutdown(cli);

4545

return rc;

4546

}

4547

4548

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

4549

Handle a -L query.

4550

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

4551

4552

static int do_host_query(const char *query_host)

4553

{

4554

cli = cli_cm_open(talloc_tos(), NULL,

4555

query_host, "IPC$", auth_info, true, smb_encrypt,

4556

max_protocol, port, name_type);

4557

if (!cli)

4558

return 1;

4559

4560

browse_host(true);

4561

4562

/* Ensure that the host can do IPv4 */

4563

4564

if (!interpret_addr(query_host)) {

4565

struct sockaddr_storage ss;

4566

if (interpret_string_addr(&ss, query_host, 0) &&

4567

(ss.ss_family != AF_INET)) {

4568

d_printf("%s is an IPv6 address -- no workgroup available\n",

4569

query_host);

4570

return 1;

4571

}

4572

}

4573

4574

if (port != 139) {

4575

4576

/* Workgroups simply don't make sense over anything

4577

else but port 139... */

4578

4579

cli_shutdown(cli);

4580

cli = cli_cm_open(talloc_tos(), NULL,

4581

query_host, "IPC$", auth_info, true, smb_encrypt,

4582

max_protocol, 139, name_type);

4583

}

4584

4585

if (cli == NULL) {

4586

d_printf("NetBIOS over TCP disabled -- no workgroup available\n");

4587

return 1;

4588

}

4589

4590

list_servers(lp_workgroup());

4591

4592

cli_shutdown(cli);

4593

4594

return(0);

4595

}

4596

4597

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

4598

Handle a tar operation.

4599

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

4600

4601

static int do_tar_op(const char *base_directory)

4602

{

4603

int ret;

4604

4605

/* do we already have a connection? */

4606

if (!cli) {

4607

cli = cli_cm_open(talloc_tos(), NULL,

4608

have_ip ? dest_ss_str : desthost,

4609

service, auth_info, true, smb_encrypt,

4610

max_protocol, port, name_type);

4611

if (!cli)

4612

return 1;

4613

}

4614

4615

recurse=true;

4616

4617

if (base_directory && *base_directory) {

4618

ret = do_cd(base_directory);

4619

if (ret) {

4620

cli_shutdown(cli);

4621

return ret;

4622

}

4623

}

4624

4625

ret=process_tar();

4626

4627

cli_shutdown(cli);

4628

4629

return(ret);

4630

}

4631

4632

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

4633

Handle a message operation.

4634

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

4635

4636

static int do_message_op(struct user_auth_info *a_info)

4637

{

4638

struct sockaddr_storage ss;

4639

struct nmb_name called, calling;

4640

fstring server_name;

4641

char name_type_hex[10];

4642

int msg_port;

4643

NTSTATUS status;

4644

4645

make_nmb_name(&calling, calling_name, 0x0);

4646

make_nmb_name(&called , desthost, name_type);

4647

4648

fstrcpy(server_name, desthost);

4649

snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);

4650

fstrcat(server_name, name_type_hex);

4651

4652

zero_sockaddr(&ss);

4653

if (have_ip)

4654

ss = dest_ss;

4655

4656

/* we can only do messages over port 139 (to windows clients at least) */

4657

4658

msg_port = port ? port : 139;

4659

4660

if (!(cli=cli_initialise())) {

4661

d_printf("Connection to %s failed\n", desthost);

4662

return 1;

4663

}

4664

cli_set_port(cli, msg_port);

4665

4666

status = cli_connect(cli, server_name, &ss);

4667

if (!NT_STATUS_IS_OK(status)) {

4668

d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));

4669

return 1;

4670

}

4671

4672

if (!cli_session_request(cli, &calling, &called)) {

4673

d_printf("session request failed\n");

4674

cli_shutdown(cli);

4675

return 1;

4676

}

4677

4678

send_message(get_cmdline_auth_info_username(a_info));

4679

cli_shutdown(cli);

4680

4681

return 0;

4682

}

4683

4684

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

4685

main program

4686

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

4687

4688

int main(int argc,char *argv[])

4689

{

4690

char *base_directory = NULL;

4691

int opt;

4692

char *query_host = NULL;

4693

bool message = false;

4694

char *term_code = NULL;

4695

static const char *new_name_resolve_order = NULL;

4696

poptContext pc;

4697

char *p;

4698

int rc = 0;

4699

fstring new_workgroup;

4700

bool tar_opt = false;

4701

bool service_opt = false;

4702

struct poptOption long_options[] = {

4703

POPT_AUTOHELP

4704

4705

{ "name-resolve", 'R', POPT_ARG_STRING, &new_name_resolve_order, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },

4706

{ "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },

4707

{ "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },

4708

{ "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },

4709

{ "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },

4710

{ "terminal", 't', POPT_ARG_STRING, NULL, 't', "Terminal I/O code {sjis|euc|jis7|jis8|junet|hex}", "CODE" },

4711

{ "max-protocol", 'm', POPT_ARG_STRING, NULL, 'm', "Set the max protocol level", "LEVEL" },

4712

{ "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },

4713

{ "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },

4714

{ "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },

4715

{ "send-buffer", 'b', POPT_ARG_INT, &io_bufsize, 'b', "Changes the transmit/send buffer", "BYTES" },

4716

{ "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },

4717

{ "grepable", 'g', POPT_ARG_NONE, NULL, 'g', "Produce grepable output" },

4718

{ "browse", 'B', POPT_ARG_NONE, NULL, 'B', "Browse SMB servers using DNS" },

4719

POPT_COMMON_SAMBA

4720

POPT_COMMON_CONNECTION

4721

POPT_COMMON_CREDENTIALS

4722

POPT_TABLEEND

4723

};

4724

TALLOC_CTX *frame = talloc_stackframe();

4725

4726

if (!client_set_cur_dir("\\")) {

4727

exit(ENOMEM);

4728

}

4729

4730

#ifdef KANJI

4731

term_code = talloc_strdup(frame,KANJI);

4732

#else /* KANJI */

4733

term_code = talloc_strdup(frame,"");

4734

#endif /* KANJI */

4735

if (!term_code) {

4736

exit(ENOMEM);

4737

}

4738

4739

/* initialize the workgroup name so we can determine whether or

4740

not it was set by a command line option */

4741

4742

set_global_myworkgroup( "" );

4743

set_global_myname( "" );

4744

4745

/* set default debug level to 1 regardless of what smb.conf sets */

4746

setup_logging( "smbclient", true );

4747

DEBUGLEVEL_CLASS[DBGC_ALL] = 1;

4748

if ((dbf = x_fdup(x_stderr))) {

4749

x_setbuf( dbf, NULL );

4750

}

4751

4752

load_case_tables();

4753

4754

auth_info = user_auth_info_init(frame);

4755

if (auth_info == NULL) {

4756

exit(1);

4757

}

4758

popt_common_set_auth_info(auth_info);

4759

4760

/* skip argv(0) */

4761

pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);

4762

poptSetOtherOptionHelp(pc, "service <password>");

4763

4764

lp_set_in_client(true); /* Make sure that we tell lp_load we are */

4765

4766

while ((opt = poptGetNextOpt(pc)) != -1) {

4767

4768

/* if the tar option has been called previouslt, now we need to eat out the leftovers */

4769

/* I see no other way to keep things sane --SSS */

4770

if (tar_opt == true) {

4771

while (poptPeekArg(pc)) {

4772

poptGetArg(pc);

4773

}

4774

tar_opt = false;

4775

}

4776

4777

/* if the service has not yet been specified lets see if it is available in the popt stack */

4778

if (!service_opt && poptPeekArg(pc)) {

4779

service = talloc_strdup(frame, poptGetArg(pc));

4780

if (!service) {

4781

exit(ENOMEM);

4782

}

4783

service_opt = true;

4784

}

4785

4786

/* if the service has already been retrieved then check if we have also a password */

4787

if (service_opt

4788

&& (!get_cmdline_auth_info_got_pass(auth_info))

4789

&& poptPeekArg(pc)) {

4790

set_cmdline_auth_info_password(auth_info,

4791

poptGetArg(pc));

4792

}

4793

4794

switch (opt) {

4795

case 'M':

4796

/* Messages are sent to NetBIOS name type 0x3

4797

* (Messenger Service). Make sure we default

4798

* to port 139 instead of port 445. srl,crh

4799

4800

name_type = 0x03;

4801

desthost = talloc_strdup(frame,poptGetOptArg(pc));

4802

if (!desthost) {

4803

exit(ENOMEM);

4804

}

4805

if( !port )

4806

port = 139;

4807

message = true;

4808

break;

4809

case 'I':

4810

{

4811

if (!interpret_string_addr(&dest_ss, poptGetOptArg(pc), 0)) {

4812

exit(1);

4813

}

4814

have_ip = true;

4815

print_sockaddr(dest_ss_str, sizeof(dest_ss_str), &dest_ss);

4816

}

4817

break;

4818

case 'E':

4819

if (dbf) {

4820

x_fclose(dbf);

4821

}

4822

dbf = x_stderr;

4823

display_set_stderr();

4824

break;

4825

4826

case 'L':

4827

query_host = talloc_strdup(frame, poptGetOptArg(pc));

4828

if (!query_host) {

4829

exit(ENOMEM);

4830

}

4831

break;

4832

case 't':

4833

term_code = talloc_strdup(frame,poptGetOptArg(pc));

4834

if (!term_code) {

4835

exit(ENOMEM);

4836

}

4837

break;

4838

case 'm':

4839

max_protocol = interpret_protocol(poptGetOptArg(pc), max_protocol);

4840

break;

4841

case 'T':

4842

/* We must use old option processing for this. Find the

4843

* position of the -T option in the raw argv[]. */

4844

{

4845

int i;

4846

for (i = 1; i < argc; i++) {

4847

if (strncmp("-T", argv[i],2)==0)

4848

break;

4849

}

4850

i++;

4851

if (!tar_parseargs(argc, argv, poptGetOptArg(pc), i)) {

4852

poptPrintUsage(pc, stderr, 0);

4853

exit(1);

4854

}

4855

}

4856

/* this must be the last option, mark we have parsed it so that we know we have */

4857

tar_opt = true;

4858

break;

4859

case 'D':

4860

base_directory = talloc_strdup(frame, poptGetOptArg(pc));

4861

if (!base_directory) {

4862

exit(ENOMEM);

4863

}

4864

break;

4865

case 'g':

4866

grepable=true;

4867

break;

4868

case 'e':

4869

smb_encrypt=true;

4870

break;

4871

case 'B':

4872

return(do_smb_browse());

4873

4874

}

4875

}

4876

4877

/* We may still have some leftovers after the last popt option has been called */

4878

if (tar_opt == true) {

4879

while (poptPeekArg(pc)) {

4880

poptGetArg(pc);

4881

}

4882

tar_opt = false;

4883

}

4884

4885

/* if the service has not yet been specified lets see if it is available in the popt stack */

4886

if (!service_opt && poptPeekArg(pc)) {

4887

service = talloc_strdup(frame,poptGetArg(pc));

4888

if (!service) {

4889

exit(ENOMEM);

4890

}

4891

service_opt = true;

4892

}

4893

4894

/* if the service has already been retrieved then check if we have also a password */

4895

if (service_opt

4896

&& !get_cmdline_auth_info_got_pass(auth_info)

4897

&& poptPeekArg(pc)) {

4898

set_cmdline_auth_info_password(auth_info,

4899

poptGetArg(pc));

4900

}

4901

4902

4903

* Don't load debug level from smb.conf. It should be

4904

* set by cmdline arg or remain default (0)

4905

4906

AllowDebugChange = false;

4907

4908

/* save the workgroup...

4909

4910

FIXME!! do we need to do this for other options as well

4911

(or maybe a generic way to keep lp_load() from overwriting

4912

everything)? */

4913

4914

fstrcpy( new_workgroup, lp_workgroup() );

4915

calling_name = talloc_strdup(frame, global_myname() );

4916

if (!calling_name) {

4917

exit(ENOMEM);

4918

}

4919

4920

if ( override_logfile )

4921

setup_logging( lp_logfile(), false );

4922

4923

if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {

4924

fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",

4925

argv[0], get_dyn_CONFIGFILE());

4926

}

4927

4928

if (get_cmdline_auth_info_use_machine_account(auth_info) &&

4929

!set_cmdline_auth_info_machine_account_creds(auth_info)) {

4930

exit(-1);

4931

}

4932

4933

load_interfaces();

4934

4935

if (service_opt && service) {

4936

size_t len;

4937

4938

/* Convert any '/' characters in the service name to '\' characters */

4939

string_replace(service, '/','\\');

4940

if (count_chars(service,'\\') < 3) {

4941

d_printf("\n%s: Not enough '\\' characters in service\n",service);

4942

poptPrintUsage(pc, stderr, 0);

4943

exit(1);

4944

}

4945

/* Remove trailing slashes */

4946

len = strlen(service);

4947

while(len > 0 && service[len - 1] == '\\') {

4948

--len;

4949

service[len] = '\0';

4950

}

4951

}

4952

4953

if ( strlen(new_workgroup) != 0 ) {

4954

set_global_myworkgroup( new_workgroup );

4955

}

4956

4957

if ( strlen(calling_name) != 0 ) {

4958

set_global_myname( calling_name );

4959

} else {

4960

TALLOC_FREE(calling_name);

4961

calling_name = talloc_strdup(frame, global_myname() );

4962

}

4963

4964

smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);

4965

if (!init_names()) {

4966

fprintf(stderr, "init_names() failed\n");

4967

exit(1);

4968

}

4969

4970

if(new_name_resolve_order)

4971

lp_set_name_resolve_order(new_name_resolve_order);

4972

4973

if (!tar_type && !query_host && !service && !message) {

4974

poptPrintUsage(pc, stderr, 0);

4975

exit(1);

4976

}

4977

4978

poptFreeContext(pc);

4979

4980

DEBUG(3,("Client started (version %s).\n", samba_version_string()));

4981

4982

/* Ensure we have a password (or equivalent). */

4983

set_cmdline_auth_info_getpass(auth_info);

4984

4985

if (tar_type) {

4986

if (cmdstr)

4987

process_command_string(cmdstr);

4988

return do_tar_op(base_directory);

4989

}

4990

4991

if (query_host && *query_host) {

4992

char *qhost = query_host;

4993

char *slash;

4994

4995

while (*qhost == '\\' || *qhost == '/')

4996

qhost++;

4997

4998

if ((slash = strchr_m(qhost, '/'))

4999

|| (slash = strchr_m(qhost, '\\'))) {

5000

*slash = 0;

5001

}

5002

5003

if ((p=strchr_m(qhost, '#'))) {

5004

*p = 0;

5005

p++;

5006

sscanf(p, "%x", &name_type);

5007

}

5008

5009

return do_host_query(qhost);

5010

}

5011

5012

if (message) {

5013

return do_message_op(auth_info);

5014

}

5015

5016

if (process(base_directory)) {

5017

return 1;

5018

}

5019

5020

TALLOC_FREE(frame);

5021

return rc;

5022

}