• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* File object implementation (what's left of it -- see io.py) */
2 
3 #define PY_SSIZE_T_CLEAN
4 #include "Python.h"
5 
6 #if defined(HAVE_GETC_UNLOCKED) && !defined(_Py_MEMORY_SANITIZER)
7 /* clang MemorySanitizer doesn't yet understand getc_unlocked. */
8 #define GETC(f) getc_unlocked(f)
9 #define FLOCKFILE(f) flockfile(f)
10 #define FUNLOCKFILE(f) funlockfile(f)
11 #else
12 #define GETC(f) getc(f)
13 #define FLOCKFILE(f)
14 #define FUNLOCKFILE(f)
15 #endif
16 
17 /* Newline flags */
18 #define NEWLINE_UNKNOWN 0       /* No newline seen, yet */
19 #define NEWLINE_CR 1            /* \r newline seen */
20 #define NEWLINE_LF 2            /* \n newline seen */
21 #define NEWLINE_CRLF 4          /* \r\n newline seen */
22 
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 
27 /* External C interface */
28 
29 PyObject *
PyFile_FromFd(int fd,const char * name,const char * mode,int buffering,const char * encoding,const char * errors,const char * newline,int closefd)30 PyFile_FromFd(int fd, const char *name, const char *mode, int buffering, const char *encoding,
31               const char *errors, const char *newline, int closefd)
32 {
33     PyObject *io, *stream;
34     _Py_IDENTIFIER(open);
35 
36     io = PyImport_ImportModule("io");
37     if (io == NULL)
38         return NULL;
39     stream = _PyObject_CallMethodId(io, &PyId_open, "isisssi", fd, mode,
40                                  buffering, encoding, errors,
41                                  newline, closefd);
42     Py_DECREF(io);
43     if (stream == NULL)
44         return NULL;
45     /* ignore name attribute because the name attribute of _BufferedIOMixin
46        and TextIOWrapper is read only */
47     return stream;
48 }
49 
50 PyObject *
PyFile_GetLine(PyObject * f,int n)51 PyFile_GetLine(PyObject *f, int n)
52 {
53     _Py_IDENTIFIER(readline);
54     PyObject *result;
55 
56     if (f == NULL) {
57         PyErr_BadInternalCall();
58         return NULL;
59     }
60 
61     if (n <= 0) {
62         result = _PyObject_CallMethodIdObjArgs(f, &PyId_readline, NULL);
63     }
64     else {
65         result = _PyObject_CallMethodId(f, &PyId_readline, "i", n);
66     }
67     if (result != NULL && !PyBytes_Check(result) &&
68         !PyUnicode_Check(result)) {
69         Py_DECREF(result);
70         result = NULL;
71         PyErr_SetString(PyExc_TypeError,
72                    "object.readline() returned non-string");
73     }
74 
75     if (n < 0 && result != NULL && PyBytes_Check(result)) {
76         char *s = PyBytes_AS_STRING(result);
77         Py_ssize_t len = PyBytes_GET_SIZE(result);
78         if (len == 0) {
79             Py_DECREF(result);
80             result = NULL;
81             PyErr_SetString(PyExc_EOFError,
82                             "EOF when reading a line");
83         }
84         else if (s[len-1] == '\n') {
85             if (result->ob_refcnt == 1)
86                 _PyBytes_Resize(&result, len-1);
87             else {
88                 PyObject *v;
89                 v = PyBytes_FromStringAndSize(s, len-1);
90                 Py_DECREF(result);
91                 result = v;
92             }
93         }
94     }
95     if (n < 0 && result != NULL && PyUnicode_Check(result)) {
96         Py_ssize_t len = PyUnicode_GET_LENGTH(result);
97         if (len == 0) {
98             Py_DECREF(result);
99             result = NULL;
100             PyErr_SetString(PyExc_EOFError,
101                             "EOF when reading a line");
102         }
103         else if (PyUnicode_READ_CHAR(result, len-1) == '\n') {
104             PyObject *v;
105             v = PyUnicode_Substring(result, 0, len-1);
106             Py_DECREF(result);
107             result = v;
108         }
109     }
110     return result;
111 }
112 
113 /* Interfaces to write objects/strings to file-like objects */
114 
115 int
PyFile_WriteObject(PyObject * v,PyObject * f,int flags)116 PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
117 {
118     PyObject *writer, *value, *result;
119     _Py_IDENTIFIER(write);
120 
121     if (f == NULL) {
122         PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
123         return -1;
124     }
125     writer = _PyObject_GetAttrId(f, &PyId_write);
126     if (writer == NULL)
127         return -1;
128     if (flags & Py_PRINT_RAW) {
129         value = PyObject_Str(v);
130     }
131     else
132         value = PyObject_Repr(v);
133     if (value == NULL) {
134         Py_DECREF(writer);
135         return -1;
136     }
137     result = PyObject_CallFunctionObjArgs(writer, value, NULL);
138     Py_DECREF(value);
139     Py_DECREF(writer);
140     if (result == NULL)
141         return -1;
142     Py_DECREF(result);
143     return 0;
144 }
145 
146 int
PyFile_WriteString(const char * s,PyObject * f)147 PyFile_WriteString(const char *s, PyObject *f)
148 {
149     if (f == NULL) {
150         /* Should be caused by a pre-existing error */
151         if (!PyErr_Occurred())
152             PyErr_SetString(PyExc_SystemError,
153                             "null file for PyFile_WriteString");
154         return -1;
155     }
156     else if (!PyErr_Occurred()) {
157         PyObject *v = PyUnicode_FromString(s);
158         int err;
159         if (v == NULL)
160             return -1;
161         err = PyFile_WriteObject(v, f, Py_PRINT_RAW);
162         Py_DECREF(v);
163         return err;
164     }
165     else
166         return -1;
167 }
168 
169 /* Try to get a file-descriptor from a Python object.  If the object
170    is an integer, its value is returned.  If not, the
171    object's fileno() method is called if it exists; the method must return
172    an integer, which is returned as the file descriptor value.
173    -1 is returned on failure.
174 */
175 
176 int
PyObject_AsFileDescriptor(PyObject * o)177 PyObject_AsFileDescriptor(PyObject *o)
178 {
179     int fd;
180     PyObject *meth;
181     _Py_IDENTIFIER(fileno);
182 
183     if (PyLong_Check(o)) {
184         fd = _PyLong_AsInt(o);
185     }
186     else if ((meth = _PyObject_GetAttrId(o, &PyId_fileno)) != NULL)
187     {
188         PyObject *fno = _PyObject_CallNoArg(meth);
189         Py_DECREF(meth);
190         if (fno == NULL)
191             return -1;
192 
193         if (PyLong_Check(fno)) {
194             fd = _PyLong_AsInt(fno);
195             Py_DECREF(fno);
196         }
197         else {
198             PyErr_SetString(PyExc_TypeError,
199                             "fileno() returned a non-integer");
200             Py_DECREF(fno);
201             return -1;
202         }
203     }
204     else {
205         PyErr_SetString(PyExc_TypeError,
206                         "argument must be an int, or have a fileno() method.");
207         return -1;
208     }
209 
210     if (fd == -1 && PyErr_Occurred())
211         return -1;
212     if (fd < 0) {
213         PyErr_Format(PyExc_ValueError,
214                      "file descriptor cannot be a negative integer (%i)",
215                      fd);
216         return -1;
217     }
218     return fd;
219 }
220 
221 /*
222 ** Py_UniversalNewlineFgets is an fgets variation that understands
223 ** all of \r, \n and \r\n conventions.
224 ** The stream should be opened in binary mode.
225 ** If fobj is NULL the routine always does newline conversion, and
226 ** it may peek one char ahead to gobble the second char in \r\n.
227 ** If fobj is non-NULL it must be a PyFileObject. In this case there
228 ** is no readahead but in stead a flag is used to skip a following
229 ** \n on the next read. Also, if the file is open in binary mode
230 ** the whole conversion is skipped. Finally, the routine keeps track of
231 ** the different types of newlines seen.
232 ** Note that we need no error handling: fgets() treats error and eof
233 ** identically.
234 */
235 char *
Py_UniversalNewlineFgets(char * buf,int n,FILE * stream,PyObject * fobj)236 Py_UniversalNewlineFgets(char *buf, int n, FILE *stream, PyObject *fobj)
237 {
238     char *p = buf;
239     int c;
240     int newlinetypes = 0;
241     int skipnextlf = 0;
242 
243     if (fobj) {
244         errno = ENXIO;          /* What can you do... */
245         return NULL;
246     }
247     FLOCKFILE(stream);
248     c = 'x'; /* Shut up gcc warning */
249     while (--n > 0 && (c = GETC(stream)) != EOF ) {
250         if (skipnextlf ) {
251             skipnextlf = 0;
252             if (c == '\n') {
253                 /* Seeing a \n here with skipnextlf true
254                 ** means we saw a \r before.
255                 */
256                 newlinetypes |= NEWLINE_CRLF;
257                 c = GETC(stream);
258                 if (c == EOF) break;
259             } else {
260                 /*
261                 ** Note that c == EOF also brings us here,
262                 ** so we're okay if the last char in the file
263                 ** is a CR.
264                 */
265                 newlinetypes |= NEWLINE_CR;
266             }
267         }
268         if (c == '\r') {
269             /* A \r is translated into a \n, and we skip
270             ** an adjacent \n, if any. We don't set the
271             ** newlinetypes flag until we've seen the next char.
272             */
273             skipnextlf = 1;
274             c = '\n';
275         } else if ( c == '\n') {
276             newlinetypes |= NEWLINE_LF;
277         }
278         *p++ = c;
279         if (c == '\n') break;
280     }
281     /* if ( c == EOF && skipnextlf )
282         newlinetypes |= NEWLINE_CR; */
283     FUNLOCKFILE(stream);
284     *p = '\0';
285     if ( skipnextlf ) {
286         /* If we have no file object we cannot save the
287         ** skipnextlf flag. We have to readahead, which
288         ** will cause a pause if we're reading from an
289         ** interactive stream, but that is very unlikely
290         ** unless we're doing something silly like
291         ** exec(open("/dev/tty").read()).
292         */
293         c = GETC(stream);
294         if ( c != '\n' )
295             ungetc(c, stream);
296     }
297     if (p == buf)
298         return NULL;
299     return buf;
300 }
301 
302 /* **************************** std printer ****************************
303  * The stdprinter is used during the boot strapping phase as a preliminary
304  * file like object for sys.stderr.
305  */
306 
307 typedef struct {
308     PyObject_HEAD
309     int fd;
310 } PyStdPrinter_Object;
311 
312 static PyObject *
stdprinter_new(PyTypeObject * type,PyObject * args,PyObject * kews)313 stdprinter_new(PyTypeObject *type, PyObject *args, PyObject *kews)
314 {
315     PyStdPrinter_Object *self;
316 
317     assert(type != NULL && type->tp_alloc != NULL);
318 
319     self = (PyStdPrinter_Object *) type->tp_alloc(type, 0);
320     if (self != NULL) {
321         self->fd = -1;
322     }
323 
324     return (PyObject *) self;
325 }
326 
327 static int
stdprinter_init(PyObject * self,PyObject * args,PyObject * kwds)328 stdprinter_init(PyObject *self, PyObject *args, PyObject *kwds)
329 {
330     PyErr_SetString(PyExc_TypeError,
331                     "cannot create 'stderrprinter' instances");
332     return -1;
333 }
334 
335 PyObject *
PyFile_NewStdPrinter(int fd)336 PyFile_NewStdPrinter(int fd)
337 {
338     PyStdPrinter_Object *self;
339 
340     if (fd != fileno(stdout) && fd != fileno(stderr)) {
341         /* not enough infrastructure for PyErr_BadInternalCall() */
342         return NULL;
343     }
344 
345     self = PyObject_New(PyStdPrinter_Object,
346                         &PyStdPrinter_Type);
347     if (self != NULL) {
348         self->fd = fd;
349     }
350     return (PyObject*)self;
351 }
352 
353 static PyObject *
stdprinter_write(PyStdPrinter_Object * self,PyObject * args)354 stdprinter_write(PyStdPrinter_Object *self, PyObject *args)
355 {
356     PyObject *unicode;
357     PyObject *bytes = NULL;
358     const char *str;
359     Py_ssize_t n;
360     int err;
361 
362     if (self->fd < 0) {
363         /* fd might be invalid on Windows
364          * I can't raise an exception here. It may lead to an
365          * unlimited recursion in the case stderr is invalid.
366          */
367         Py_RETURN_NONE;
368     }
369 
370     if (!PyArg_ParseTuple(args, "U", &unicode))
371         return NULL;
372 
373     /* encode Unicode to UTF-8 */
374     str = PyUnicode_AsUTF8AndSize(unicode, &n);
375     if (str == NULL) {
376         PyErr_Clear();
377         bytes = _PyUnicode_AsUTF8String(unicode, "backslashreplace");
378         if (bytes == NULL)
379             return NULL;
380         str = PyBytes_AS_STRING(bytes);
381         n = PyBytes_GET_SIZE(bytes);
382     }
383 
384     n = _Py_write(self->fd, str, n);
385     /* save errno, it can be modified indirectly by Py_XDECREF() */
386     err = errno;
387 
388     Py_XDECREF(bytes);
389 
390     if (n == -1) {
391         if (err == EAGAIN) {
392             PyErr_Clear();
393             Py_RETURN_NONE;
394         }
395         return NULL;
396     }
397 
398     return PyLong_FromSsize_t(n);
399 }
400 
401 static PyObject *
stdprinter_fileno(PyStdPrinter_Object * self)402 stdprinter_fileno(PyStdPrinter_Object *self)
403 {
404     return PyLong_FromLong((long) self->fd);
405 }
406 
407 static PyObject *
stdprinter_repr(PyStdPrinter_Object * self)408 stdprinter_repr(PyStdPrinter_Object *self)
409 {
410     return PyUnicode_FromFormat("<stdprinter(fd=%d) object at %p>",
411                                 self->fd, self);
412 }
413 
414 static PyObject *
stdprinter_noop(PyStdPrinter_Object * self)415 stdprinter_noop(PyStdPrinter_Object *self)
416 {
417     Py_RETURN_NONE;
418 }
419 
420 static PyObject *
stdprinter_isatty(PyStdPrinter_Object * self)421 stdprinter_isatty(PyStdPrinter_Object *self)
422 {
423     long res;
424     if (self->fd < 0) {
425         Py_RETURN_FALSE;
426     }
427 
428     Py_BEGIN_ALLOW_THREADS
429     res = isatty(self->fd);
430     Py_END_ALLOW_THREADS
431 
432     return PyBool_FromLong(res);
433 }
434 
435 static PyMethodDef stdprinter_methods[] = {
436     {"close",           (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
437     {"flush",           (PyCFunction)stdprinter_noop, METH_NOARGS, ""},
438     {"fileno",          (PyCFunction)stdprinter_fileno, METH_NOARGS, ""},
439     {"isatty",          (PyCFunction)stdprinter_isatty, METH_NOARGS, ""},
440     {"write",           (PyCFunction)stdprinter_write, METH_VARARGS, ""},
441     {NULL,              NULL}  /*sentinel */
442 };
443 
444 static PyObject *
get_closed(PyStdPrinter_Object * self,void * closure)445 get_closed(PyStdPrinter_Object *self, void *closure)
446 {
447     Py_RETURN_FALSE;
448 }
449 
450 static PyObject *
get_mode(PyStdPrinter_Object * self,void * closure)451 get_mode(PyStdPrinter_Object *self, void *closure)
452 {
453     return PyUnicode_FromString("w");
454 }
455 
456 static PyObject *
get_encoding(PyStdPrinter_Object * self,void * closure)457 get_encoding(PyStdPrinter_Object *self, void *closure)
458 {
459     Py_RETURN_NONE;
460 }
461 
462 static PyGetSetDef stdprinter_getsetlist[] = {
463     {"closed", (getter)get_closed, NULL, "True if the file is closed"},
464     {"encoding", (getter)get_encoding, NULL, "Encoding of the file"},
465     {"mode", (getter)get_mode, NULL, "String giving the file mode"},
466     {0},
467 };
468 
469 PyTypeObject PyStdPrinter_Type = {
470     PyVarObject_HEAD_INIT(&PyType_Type, 0)
471     "stderrprinter",                            /* tp_name */
472     sizeof(PyStdPrinter_Object),                /* tp_basicsize */
473     0,                                          /* tp_itemsize */
474     /* methods */
475     0,                                          /* tp_dealloc */
476     0,                                          /* tp_print */
477     0,                                          /* tp_getattr */
478     0,                                          /* tp_setattr */
479     0,                                          /* tp_reserved */
480     (reprfunc)stdprinter_repr,                  /* tp_repr */
481     0,                                          /* tp_as_number */
482     0,                                          /* tp_as_sequence */
483     0,                                          /* tp_as_mapping */
484     0,                                          /* tp_hash */
485     0,                                          /* tp_call */
486     0,                                          /* tp_str */
487     PyObject_GenericGetAttr,                    /* tp_getattro */
488     0,                                          /* tp_setattro */
489     0,                                          /* tp_as_buffer */
490     Py_TPFLAGS_DEFAULT,                         /* tp_flags */
491     0,                                          /* tp_doc */
492     0,                                          /* tp_traverse */
493     0,                                          /* tp_clear */
494     0,                                          /* tp_richcompare */
495     0,                                          /* tp_weaklistoffset */
496     0,                                          /* tp_iter */
497     0,                                          /* tp_iternext */
498     stdprinter_methods,                         /* tp_methods */
499     0,                                          /* tp_members */
500     stdprinter_getsetlist,                      /* tp_getset */
501     0,                                          /* tp_base */
502     0,                                          /* tp_dict */
503     0,                                          /* tp_descr_get */
504     0,                                          /* tp_descr_set */
505     0,                                          /* tp_dictoffset */
506     stdprinter_init,                            /* tp_init */
507     PyType_GenericAlloc,                        /* tp_alloc */
508     stdprinter_new,                             /* tp_new */
509     PyObject_Del,                               /* tp_free */
510 };
511 
512 
513 #ifdef __cplusplus
514 }
515 #endif
516