cpython/Modules/fcntlmodule.c at 3.5 · python/cpython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

/* fcntl module */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#ifdef HAVE_SYS_FILE_H

#include <sys/file.h>

#endif

#include <sys/ioctl.h>

#include <fcntl.h>

#ifdef HAVE_STROPTS_H

#include <stropts.h>

#endif

/*[clinic input]

module fcntl

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=124b58387c158179]*/

static int

conv_descriptor(PyObject *object, int *target)

{

int fd = PyObject_AsFileDescriptor(object);

if (fd < 0)

return 0;

*target = fd;

return 1;

}

/* Must come after conv_descriptor definition. */

#include "clinic/fcntlmodule.c.h"

/*[clinic input]

fcntl.fcntl

fd: object(type='int', converter='conv_descriptor')

cmd as code: int

arg: object(c_default='NULL') = 0

Perform the operation `cmd` on file descriptor fd.

The values used for `cmd` are operating system dependent, and are available

as constants in the fcntl module, using the same names as used in

the relevant C header files. The argument arg is optional, and

defaults to 0; it may be an int or a string. If arg is given as a string,

the return value of fcntl is a string of that length, containing the

resulting value put in the arg buffer by the operating system. The length

of the arg string is not allowed to exceed 1024 bytes. If the arg given

is an integer or if none is specified, the result value is an integer

corresponding to the return value of the fcntl call in the C code.

[clinic start generated code]*/

static PyObject *

fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)

/*[clinic end generated code: output=888fc93b51c295bd input=8cefbe59b29efbe2]*/

{

unsigned int int_arg = 0;

int ret;

char *str;

Py_ssize_t len;

char buf[1024];

if (arg != NULL) {

int parse_result;

if (PyArg_Parse(arg, "s#", &str, &len)) {

if ((size_t)len > sizeof buf) {

PyErr_SetString(PyExc_ValueError,

"fcntl string arg too long");

return NULL;

}

memcpy(buf, str, len);

Py_BEGIN_ALLOW_THREADS

ret = fcntl(fd, code, buf);

Py_END_ALLOW_THREADS

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

return PyBytes_FromStringAndSize(buf, len);

}

PyErr_Clear();

parse_result = PyArg_Parse(arg,

"I;fcntl requires a file or file descriptor,"

" an integer and optionally a third integer or a string",

&int_arg);

if (!parse_result) {

return NULL;

}

Py_BEGIN_ALLOW_THREADS

ret = fcntl(fd, code, (int)int_arg);

Py_END_ALLOW_THREADS

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

return PyLong_FromLong((long)ret);

}

/*[clinic input]

fcntl.ioctl

fd: object(type='int', converter='conv_descriptor')

request as code: unsigned_int(bitwise=True)

arg as ob_arg: object(c_default='NULL') = 0

mutate_flag as mutate_arg: bool = True

Perform the operation `request` on file descriptor `fd`.

The values used for `request` are operating system dependent, and are available

as constants in the fcntl or termios library modules, using the same names as

used in the relevant C header files.

The argument `arg` is optional, and defaults to 0; it may be an int or a

buffer containing character data (most likely a string or an array).

If the argument is a mutable buffer (such as an array) and if the

mutate_flag argument (which is only allowed in this case) is true then the

buffer is (in effect) passed to the operating system and changes made by

the OS will be reflected in the contents of the buffer after the call has

returned. The return value is the integer returned by the ioctl system

call.

If the argument is a mutable buffer and the mutable_flag argument is false,

the behavior is as if a string had been passed.

If the argument is an immutable buffer (most likely a string) then a copy

of the buffer is passed to the operating system and the return value is a

string of the same length containing whatever the operating system put in

the buffer. The length of the arg buffer in this case is not allowed to

exceed 1024 bytes.

If the arg given is an integer or if none is specified, the result value is

an integer corresponding to the return value of the ioctl call in the C

code.

[clinic start generated code]*/

static PyObject *

fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,

PyObject *ob_arg, int mutate_arg)

/*[clinic end generated code: output=7f7f5840c65991be input=ede70c433cccbbb2]*/

{

#define IOCTL_BUFSZ 1024

/* We use the unsigned non-checked 'I' format for the 'code' parameter

because the system expects it to be a 32bit bit field value

regardless of it being passed as an int or unsigned long on

various platforms. See the termios.TIOCSWINSZ constant across

platforms for an example of this.

If any of the 64bit platforms ever decide to use more than 32bits

in their unsigned long ioctl codes this will break and need

special casing based on the platform being built on.

int arg = 0;

int ret;

Py_buffer pstr;

char *str;

Py_ssize_t len;

char buf[IOCTL_BUFSZ+1]; /* argument plus NUL byte */

if (ob_arg != NULL) {

if (PyArg_Parse(ob_arg, "w*:ioctl", &pstr)) {

char *arg;

str = pstr.buf;

len = pstr.len;

if (mutate_arg) {

if (len <= IOCTL_BUFSZ) {

memcpy(buf, str, len);

buf[len] = '\0';

arg = buf;

}

else {

arg = str;

}

else {

if (len > IOCTL_BUFSZ) {

PyBuffer_Release(&pstr);

PyErr_SetString(PyExc_ValueError,

"ioctl string arg too long");

return NULL;

}

else {

memcpy(buf, str, len);

buf[len] = '\0';

arg = buf;

}

if (buf == arg) {

Py_BEGIN_ALLOW_THREADS /* think array.resize() */

ret = ioctl(fd, code, arg);

Py_END_ALLOW_THREADS

}

else {

ret = ioctl(fd, code, arg);

}

if (mutate_arg && (len <= IOCTL_BUFSZ)) {

memcpy(str, buf, len);

}

PyBuffer_Release(&pstr); /* No further access to str below this point */

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

if (mutate_arg) {

return PyLong_FromLong(ret);

}

else {

return PyBytes_FromStringAndSize(buf, len);

}

PyErr_Clear();

if (PyArg_Parse(ob_arg, "s*:ioctl", &pstr)) {

str = pstr.buf;

len = pstr.len;

if (len > IOCTL_BUFSZ) {

PyBuffer_Release(&pstr);

PyErr_SetString(PyExc_ValueError,

"ioctl string arg too long");

return NULL;

}

memcpy(buf, str, len);

buf[len] = '\0';

Py_BEGIN_ALLOW_THREADS

ret = ioctl(fd, code, buf);

Py_END_ALLOW_THREADS

if (ret < 0) {

PyBuffer_Release(&pstr);

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

PyBuffer_Release(&pstr);

return PyBytes_FromStringAndSize(buf, len);

}

PyErr_Clear();

if (!PyArg_Parse(ob_arg,

"i;ioctl requires a file or file descriptor,"

" an integer and optionally an integer or buffer argument",

&arg)) {

return NULL;

}

// Fall-through to outside the 'if' statement.

}

Py_BEGIN_ALLOW_THREADS

ret = ioctl(fd, code, arg);

Py_END_ALLOW_THREADS

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

return PyLong_FromLong((long)ret);

#undef IOCTL_BUFSZ

}

/*[clinic input]

fcntl.flock

fd: object(type='int', converter='conv_descriptor')

operation as code: int

Perform the lock operation `operation` on file descriptor `fd`.

See the Unix manual page for flock(2) for details (On some systems, this

function is emulated using fcntl()).

[clinic start generated code]*/

static PyObject *

fcntl_flock_impl(PyObject *module, int fd, int code)

/*[clinic end generated code: output=84059e2b37d2fc64 input=b70a0a41ca22a8a0]*/

{

int ret;

#ifdef HAVE_FLOCK

Py_BEGIN_ALLOW_THREADS

ret = flock(fd, code);

Py_END_ALLOW_THREADS

#else

#ifndef LOCK_SH

#define LOCK_SH 1 /* shared lock */

#define LOCK_EX 2 /* exclusive lock */

#define LOCK_NB 4 /* don't block when locking */

#define LOCK_UN 8 /* unlock */

#endif

{

struct flock l;

if (code == LOCK_UN)

l.l_type = F_UNLCK;

else if (code & LOCK_SH)

l.l_type = F_RDLCK;

else if (code & LOCK_EX)

l.l_type = F_WRLCK;

else {

PyErr_SetString(PyExc_ValueError,

"unrecognized flock argument");

return NULL;

}

l.l_whence = l.l_start = l.l_len = 0;

Py_BEGIN_ALLOW_THREADS

ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);

Py_END_ALLOW_THREADS

}

#endif /* HAVE_FLOCK */

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

Py_RETURN_NONE;

}

/*[clinic input]

fcntl.lockf

fd: object(type='int', converter='conv_descriptor')

cmd as code: int

len as lenobj: object(c_default='NULL') = 0

start as startobj: object(c_default='NULL') = 0

whence: int = 0

A wrapper around the fcntl() locking calls.

`fd` is the file descriptor of the file to lock or unlock, and operation is one

of the following values:

LOCK_UN - unlock

LOCK_SH - acquire a shared lock

LOCK_EX - acquire an exclusive lock

When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with

LOCK_NB to avoid blocking on lock acquisition. If LOCK_NB is used and the

lock cannot be acquired, an OSError will be raised and the exception will

have an errno attribute set to EACCES or EAGAIN (depending on the operating

system -- for portability, check for either value).

`len` is the number of bytes to lock, with the default meaning to lock to

EOF. `start` is the byte offset, relative to `whence`, to that the lock

starts. `whence` is as with fileobj.seek(), specifically:

0 - relative to the start of the file (SEEK_SET)

1 - relative to the current buffer position (SEEK_CUR)

2 - relative to the end of the file (SEEK_END)

[clinic start generated code]*/

static PyObject *

fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,

PyObject *startobj, int whence)

/*[clinic end generated code: output=4985e7a172e7461a input=3a5dc01b04371f1a]*/

{

int ret;

#ifndef LOCK_SH

#define LOCK_SH 1 /* shared lock */

#define LOCK_EX 2 /* exclusive lock */

#define LOCK_NB 4 /* don't block when locking */

#define LOCK_UN 8 /* unlock */

#endif /* LOCK_SH */

{

struct flock l;

if (code == LOCK_UN)

l.l_type = F_UNLCK;

else if (code & LOCK_SH)

l.l_type = F_RDLCK;

else if (code & LOCK_EX)

l.l_type = F_WRLCK;

else {

PyErr_SetString(PyExc_ValueError,

"unrecognized lockf argument");

return NULL;

}

l.l_start = l.l_len = 0;

if (startobj != NULL) {

#if !defined(HAVE_LARGEFILE_SUPPORT)

l.l_start = PyLong_AsLong(startobj);

#else

l.l_start = PyLong_Check(startobj) ?

PyLong_AsLongLong(startobj) :

PyLong_AsLong(startobj);

#endif

if (PyErr_Occurred())

return NULL;

}

if (lenobj != NULL) {

#if !defined(HAVE_LARGEFILE_SUPPORT)

l.l_len = PyLong_AsLong(lenobj);

#else

l.l_len = PyLong_Check(lenobj) ?

PyLong_AsLongLong(lenobj) :

PyLong_AsLong(lenobj);

#endif

if (PyErr_Occurred())

return NULL;

}

l.l_whence = whence;

Py_BEGIN_ALLOW_THREADS

ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);

Py_END_ALLOW_THREADS

}

if (ret < 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

Py_RETURN_NONE;

}

/* List of functions */

static PyMethodDef fcntl_methods[] = {

FCNTL_FCNTL_METHODDEF

FCNTL_IOCTL_METHODDEF

FCNTL_FLOCK_METHODDEF

FCNTL_LOCKF_METHODDEF

{NULL, NULL} /* sentinel */

};

PyDoc_STRVAR(module_doc,

"This module performs file control and I/O control on file \n\

descriptors. It is an interface to the fcntl() and ioctl() Unix\n\

routines. File descriptors can be obtained with the fileno() method of\n\

a file or socket object.");

/* Module initialisation */

static int

all_ins(PyObject* m)

{

if (PyModule_AddIntMacro(m, LOCK_SH)) return -1;

if (PyModule_AddIntMacro(m, LOCK_EX)) return -1;

if (PyModule_AddIntMacro(m, LOCK_NB)) return -1;

if (PyModule_AddIntMacro(m, LOCK_UN)) return -1;

/* GNU extensions, as of glibc 2.2.4 */

#ifdef LOCK_MAND

if (PyModule_AddIntMacro(m, LOCK_MAND)) return -1;

#endif

#ifdef LOCK_READ

if (PyModule_AddIntMacro(m, LOCK_READ)) return -1;

#endif

#ifdef LOCK_WRITE

if (PyModule_AddIntMacro(m, LOCK_WRITE)) return -1;

#endif

#ifdef LOCK_RW

if (PyModule_AddIntMacro(m, LOCK_RW)) return -1;

#endif

#ifdef F_DUPFD

if (PyModule_AddIntMacro(m, F_DUPFD)) return -1;

#endif

#ifdef F_DUPFD_CLOEXEC

if (PyModule_AddIntMacro(m, F_DUPFD_CLOEXEC)) return -1;

#endif

#ifdef F_GETFD

if (PyModule_AddIntMacro(m, F_GETFD)) return -1;

#endif

#ifdef F_SETFD

if (PyModule_AddIntMacro(m, F_SETFD)) return -1;

#endif

#ifdef F_GETFL

if (PyModule_AddIntMacro(m, F_GETFL)) return -1;

#endif

#ifdef F_SETFL

if (PyModule_AddIntMacro(m, F_SETFL)) return -1;

#endif

#ifdef F_GETLK

if (PyModule_AddIntMacro(m, F_GETLK)) return -1;

#endif

#ifdef F_SETLK

if (PyModule_AddIntMacro(m, F_SETLK)) return -1;

#endif

#ifdef F_SETLKW

if (PyModule_AddIntMacro(m, F_SETLKW)) return -1;

#endif

#ifdef F_GETOWN

if (PyModule_AddIntMacro(m, F_GETOWN)) return -1;

#endif

#ifdef F_SETOWN

if (PyModule_AddIntMacro(m, F_SETOWN)) return -1;

#endif

#ifdef F_GETSIG

if (PyModule_AddIntMacro(m, F_GETSIG)) return -1;

#endif

#ifdef F_SETSIG

if (PyModule_AddIntMacro(m, F_SETSIG)) return -1;

#endif

#ifdef F_RDLCK

if (PyModule_AddIntMacro(m, F_RDLCK)) return -1;

#endif

#ifdef F_WRLCK

if (PyModule_AddIntMacro(m, F_WRLCK)) return -1;

#endif

#ifdef F_UNLCK

if (PyModule_AddIntMacro(m, F_UNLCK)) return -1;

#endif

/* LFS constants */

#ifdef F_GETLK64

if (PyModule_AddIntMacro(m, F_GETLK64)) return -1;

#endif

#ifdef F_SETLK64

if (PyModule_AddIntMacro(m, F_SETLK64)) return -1;

#endif

#ifdef F_SETLKW64

if (PyModule_AddIntMacro(m, F_SETLKW64)) return -1;

#endif

/* GNU extensions, as of glibc 2.2.4. */

#ifdef FASYNC

if (PyModule_AddIntMacro(m, FASYNC)) return -1;

#endif

#ifdef F_SETLEASE

if (PyModule_AddIntMacro(m, F_SETLEASE)) return -1;

#endif

#ifdef F_GETLEASE

if (PyModule_AddIntMacro(m, F_GETLEASE)) return -1;

#endif

#ifdef F_NOTIFY

if (PyModule_AddIntMacro(m, F_NOTIFY)) return -1;

#endif

/* Old BSD flock(). */

#ifdef F_EXLCK

if (PyModule_AddIntMacro(m, F_EXLCK)) return -1;

#endif

#ifdef F_SHLCK

if (PyModule_AddIntMacro(m, F_SHLCK)) return -1;

#endif

/* OS X specifics */

#ifdef F_FULLFSYNC

if (PyModule_AddIntMacro(m, F_FULLFSYNC)) return -1;

#endif

#ifdef F_NOCACHE

if (PyModule_AddIntMacro(m, F_NOCACHE)) return -1;

#endif

/* For F_{GET|SET}FL */

#ifdef FD_CLOEXEC

if (PyModule_AddIntMacro(m, FD_CLOEXEC)) return -1;

#endif

/* For F_NOTIFY */

#ifdef DN_ACCESS

if (PyModule_AddIntMacro(m, DN_ACCESS)) return -1;

#endif

#ifdef DN_MODIFY

if (PyModule_AddIntMacro(m, DN_MODIFY)) return -1;

#endif

#ifdef DN_CREATE

if (PyModule_AddIntMacro(m, DN_CREATE)) return -1;

#endif

#ifdef DN_DELETE

if (PyModule_AddIntMacro(m, DN_DELETE)) return -1;

#endif

#ifdef DN_RENAME

if (PyModule_AddIntMacro(m, DN_RENAME)) return -1;

#endif

#ifdef DN_ATTRIB

if (PyModule_AddIntMacro(m, DN_ATTRIB)) return -1;

#endif

#ifdef DN_MULTISHOT

if (PyModule_AddIntMacro(m, DN_MULTISHOT)) return -1;

#endif

#ifdef HAVE_STROPTS_H

/* Unix 98 guarantees that these are in stropts.h. */

if (PyModule_AddIntMacro(m, I_PUSH)) return -1;

if (PyModule_AddIntMacro(m, I_POP)) return -1;

if (PyModule_AddIntMacro(m, I_LOOK)) return -1;

if (PyModule_AddIntMacro(m, I_FLUSH)) return -1;

if (PyModule_AddIntMacro(m, I_FLUSHBAND)) return -1;

if (PyModule_AddIntMacro(m, I_SETSIG)) return -1;

if (PyModule_AddIntMacro(m, I_GETSIG)) return -1;

if (PyModule_AddIntMacro(m, I_FIND)) return -1;

if (PyModule_AddIntMacro(m, I_PEEK)) return -1;

if (PyModule_AddIntMacro(m, I_SRDOPT)) return -1;

if (PyModule_AddIntMacro(m, I_GRDOPT)) return -1;

if (PyModule_AddIntMacro(m, I_NREAD)) return -1;

if (PyModule_AddIntMacro(m, I_FDINSERT)) return -1;

if (PyModule_AddIntMacro(m, I_STR)) return -1;

if (PyModule_AddIntMacro(m, I_SWROPT)) return -1;

#ifdef I_GWROPT

/* despite the comment above, old-ish glibcs miss a couple... */

if (PyModule_AddIntMacro(m, I_GWROPT)) return -1;

#endif

if (PyModule_AddIntMacro(m, I_SENDFD)) return -1;

if (PyModule_AddIntMacro(m, I_RECVFD)) return -1;

if (PyModule_AddIntMacro(m, I_LIST)) return -1;

if (PyModule_AddIntMacro(m, I_ATMARK)) return -1;

if (PyModule_AddIntMacro(m, I_CKBAND)) return -1;

if (PyModule_AddIntMacro(m, I_GETBAND)) return -1;

if (PyModule_AddIntMacro(m, I_CANPUT)) return -1;

if (PyModule_AddIntMacro(m, I_SETCLTIME)) return -1;

#ifdef I_GETCLTIME

if (PyModule_AddIntMacro(m, I_GETCLTIME)) return -1;

#endif

if (PyModule_AddIntMacro(m, I_LINK)) return -1;

if (PyModule_AddIntMacro(m, I_UNLINK)) return -1;

if (PyModule_AddIntMacro(m, I_PLINK)) return -1;

if (PyModule_AddIntMacro(m, I_PUNLINK)) return -1;

#endif

return 0;

}

static struct PyModuleDef fcntlmodule = {

PyModuleDef_HEAD_INIT,

"fcntl",

module_doc,

-1,

fcntl_methods,

NULL,

NULL

};

PyMODINIT_FUNC

PyInit_fcntl(void)

{

PyObject *m;

/* Create the module and add the functions and documentation */

m = PyModule_Create(&fcntlmodule);

if (m == NULL)

return NULL;

/* Add some symbolic constants to the module */

if (all_ins(m) < 0)

return NULL;

return m;

}

cpython/Modules/fcntlmodule.c at 3.5 · python/cpython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

fcntlmodule.c

Latest commit

History

Breadcrumbs

fcntlmodule.c

File metadata and controls