static PyObject * flow_FlowLog(PyObject *self, PyObject *args, PyObject *kw_args) { FlowLogObject *rv; static char *keywords[] = { "path", "mode", NULL }; char *path = NULL, *mode = "rb"; if (!PyArg_ParseTupleAndKeywords(args, kw_args, "s|s:FlowLog", keywords, &path, &mode)) return NULL; if ((rv = PyObject_New(FlowLogObject, &FlowLog_Type)) == NULL) return (NULL); if ((rv->flowlog = PyFile_FromString(path, mode)) == NULL) return (NULL); PyFile_SetBufSize(rv->flowlog, 8192); return (PyObject *)rv; }
static PyObject * flow_FlowLog_fromfile(PyObject *self, PyObject *args, PyObject *kw_args) { FlowLogObject *rv; static char *keywords[] = { "file", NULL }; PyObject *file = NULL; if (!PyArg_ParseTupleAndKeywords(args, kw_args, "O!:FlowLog_fromfile", keywords, &PyFile_Type, (PyObject *)&file)) return NULL; if ((rv = PyObject_New(FlowLogObject, &FlowLog_Type)) == NULL) return (NULL); Py_INCREF(file); rv->flowlog = file; PyFile_SetBufSize(rv->flowlog, 8192); return (PyObject *)rv; }
static PyObject *posixfile(PyObject *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"name", "mode", "buffering", NULL}; PyObject *file_obj = NULL; char *name = NULL; char *mode = "rb"; DWORD access = 0; DWORD creation; HANDLE handle; int fd, flags = 0; int bufsize = -1; char m0, m1, m2; char fpmode[4]; int fppos = 0; int plus; FILE *fp; if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:posixfile", kwlist, Py_FileSystemDefaultEncoding, &name, &mode, &bufsize)) return NULL; m0 = mode[0]; m1 = m0 ? mode[1] : '\0'; m2 = m1 ? mode[2] : '\0'; plus = m1 == '+' || m2 == '+'; fpmode[fppos++] = m0; if (m1 == 'b' || m2 == 'b') { flags = _O_BINARY; fpmode[fppos++] = 'b'; } else flags = _O_TEXT; if (plus) { flags |= _O_RDWR; access = GENERIC_READ | GENERIC_WRITE; fpmode[fppos++] = '+'; } fpmode[fppos++] = '\0'; switch (m0) { case 'r': creation = OPEN_EXISTING; if (!plus) { flags |= _O_RDONLY; access = GENERIC_READ; } break; case 'w': creation = CREATE_ALWAYS; if (!plus) { access = GENERIC_WRITE; flags |= _O_WRONLY; } break; case 'a': creation = OPEN_ALWAYS; flags |= _O_APPEND; if (!plus) { flags |= _O_WRONLY; access = GENERIC_WRITE; } break; default: PyErr_Format(PyExc_ValueError, "mode string must begin with one of 'r', 'w', " "or 'a', not '%c'", m0); goto bail; } handle = CreateFile(name, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, creation, FILE_ATTRIBUTE_NORMAL, 0); if (handle == INVALID_HANDLE_VALUE) { PyErr_SetFromWindowsErrWithFilename(GetLastError(), name); goto bail; } fd = _open_osfhandle((intptr_t)handle, flags); if (fd == -1) { CloseHandle(handle); PyErr_SetFromErrnoWithFilename(PyExc_IOError, name); goto bail; } #ifndef IS_PY3K fp = _fdopen(fd, fpmode); if (fp == NULL) { _close(fd); PyErr_SetFromErrnoWithFilename(PyExc_IOError, name); goto bail; } file_obj = PyFile_FromFile(fp, name, mode, fclose); if (file_obj == NULL) { fclose(fp); goto bail; } PyFile_SetBufSize(file_obj, bufsize); #else file_obj = PyFile_FromFd(fd, name, mode, bufsize, NULL, NULL, NULL, 1); if (file_obj == NULL) goto bail; #endif bail: PyMem_Free(name); return file_obj; }
static PyObject * obj_read(PyObject *self, PyObject *args) { /* The :compress tells PyArg_ParseTuple what function to use * in its error message */ char *pstr; if (!PyArg_ParseTuple(args, "s:read", &pstr)) { return NULL; } PyFileObject* f; f = PyFile_FromString((char*) pstr, "r"); int bufsize = -1; PyObject* faces = PyList_New(0); PyObject* points = PyList_New(0); PyObject* normals = PyList_New(0); PyObject* faces_normals = PyList_New(0); if (f != NULL) { PyFile_SetBufSize(f, bufsize); for (;;) { /* From PyFile_GetLine doc * * If n is 0, exactly one line is read, * regardless of the length of the line. If n is * greater than 0, no more than n bytes will be read * from the file; a partial line can be returned. In * both cases, an empty string is returned if the end * of the file is reached immediately. */ PyObject* line = PyFile_GetLine(f, 0); /* Invalid line ? */ if (! line || ! PyString_Check(line)) break; /* Empty line ? */ int num = PyString_Size(line); if (num == 0) break; /* * sscanf params * http://www.cs.utah.edu/~zachary/isp/tutorials/io/io.html */ char* cline = PyString_AsString(line); if (cline[0] == 'f') { char p1[255]; int has_normals = 0; int f1, f2, f3, f4; int n1, n2, n3, n4; int tmp; int cnt = sscanf(cline+2, "%s %s %s %s", p1, p1, p1, p1); // printf("%d\n", cnt); if (strchr(p1, '/') == NULL) { if (cnt == 3) sscanf(cline+2, "%d %d %d", &f1, &f2, &f3); else sscanf(cline+2, "%d %d %d", &f1, &f2, &f3); } else { has_normals = 1; if (strstr(p1, "//")) { if (cnt == 3) sscanf(cline+2, "%d//%d %d//%d %d//%d", &f1, &n1, &f2, &n2, &f3, &n3); else sscanf(cline+2, "%d//%d %d//%d %d//%d %d//%d", &f1, &n1, &f2, &n2, &f3, &n3, &f4, &n4); } else { if (cnt == 3) sscanf(cline+2, "%d/%d/%d %d/%d/%d %d/%d/%d", &f1, &tmp, &n1, &f2, &tmp, &n2, &f3, &tmp, &n3); else { sscanf(cline+2, "%d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", &f1, &tmp, &n1, &f2, &tmp, &n2, &f3, &tmp, &n3, &f4, &tmp, &n4); } } } PyObject* face = PyList_New(3); PyList_SetItem(face, 0, PyInt_FromLong(f1-1)); PyList_SetItem(face, 1, PyInt_FromLong(f2-1)); PyList_SetItem(face, 2, PyInt_FromLong(f3-1)); PyList_Append(faces, face); if (cnt == 4) { PyObject* face2 = PyList_New(3); PyList_SetItem(face2, 0, PyInt_FromLong(f3-1)); PyList_SetItem(face2, 1, PyInt_FromLong(f4-1)); PyList_SetItem(face2, 2, PyInt_FromLong(f1-1)); PyList_Append(faces, face2); } if (has_normals) { PyObject* n = PyList_New(3); PyList_SetItem(n, 0, PyInt_FromLong(n1-1)); PyList_SetItem(n, 1, PyInt_FromLong(n2-1)); PyList_SetItem(n, 2, PyInt_FromLong(n3-1)); PyList_Append(faces_normals, n); if (cnt == 4) { PyObject* p = PyList_New(3); PyList_SetItem(p, 0, PyInt_FromLong(n3-1)); PyList_SetItem(p, 1, PyInt_FromLong(n4-1)); PyList_SetItem(p, 2, PyInt_FromLong(n1-1)); PyList_Append(faces_normals, p); } } } else if (cline[0] == 'v' && cline[1] == ' ') { double a, b, c; PyObject* vertex = PyList_New(3); sscanf(cline+2, "%lf %lf %lf", &a, &b, &c); // printf("%lf %lf %lf\n", a, b, c); PyList_SetItem(vertex, 0, PyFloat_FromDouble(a)); PyList_SetItem(vertex, 1, PyFloat_FromDouble(b)); PyList_SetItem(vertex, 2, PyFloat_FromDouble(c)); PyList_Append(points, vertex); } else if (cline[0] == 'v' && cline[1] == 'n') { double a, b, c; PyObject* normal = PyList_New(3); sscanf(cline+3, "%lf %lf %lf", &a, &b, &c); // printf("%lf %lf %lf\n", a, b, c); PyList_SetItem(normal, 0, PyFloat_FromDouble(a)); PyList_SetItem(normal, 1, PyFloat_FromDouble(b)); PyList_SetItem(normal, 2, PyFloat_FromDouble(c)); PyList_Append(normals, normal); } } } fclose(PyFile_AsFile(f)); PyObject* tuple = PyList_New(4); PyList_SetItem(tuple, 0, points); PyList_SetItem(tuple, 1, faces); PyList_SetItem(tuple, 2, normals); PyList_SetItem(tuple, 3, faces_normals); return tuple; }
// The following code is based off of KB: Q190351 static PyObject *_PyPopen(char *cmdstring, int mode, int n) { HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr, hChildStderrRd, hChildStderrWr, hChildStdinWrDup, hChildStdoutRdDup, hChildStderrRdDup, hProcess; // hChildStdoutWrDup; SECURITY_ATTRIBUTES saAttr; BOOL fSuccess; int fd1, fd2, fd3; FILE *f1, *f2, *f3; long file_count; PyObject *f; saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) return PyWin_SetAPIError("CreatePipe"); // Create new output read handle and the input write handle. Set // the inheritance properties to FALSE. Otherwise, the child inherits // the these handles; resulting in non-closeable handles to the pipes // being created. fSuccess = DuplicateHandle( GetCurrentProcess(), hChildStdinWr, GetCurrentProcess(), &hChildStdinWrDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return PyWin_SetAPIError("DuplicateHandle"); // Close the inheritable version of ChildStdin // that we're using. CloseHandle(hChildStdinWr); if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) return PyWin_SetAPIError("CreatePipe"); fSuccess = DuplicateHandle( GetCurrentProcess(), hChildStdoutRd, GetCurrentProcess(), &hChildStdoutRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return PyWin_SetAPIError("DuplicateHandle"); // Close the inheritable version of ChildStdout // that we're using. CloseHandle(hChildStdoutRd); if (n != POPEN_4) { if (!CreatePipe(&hChildStderrRd, &hChildStderrWr, &saAttr, 0)) return PyWin_SetAPIError("CreatePipe"); fSuccess = DuplicateHandle( GetCurrentProcess(), hChildStderrRd, GetCurrentProcess(), &hChildStderrRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return PyWin_SetAPIError("DuplicateHandle"); // Close the inheritable version of ChildStdErr that we're using. CloseHandle(hChildStderrRd); } switch (n) { case POPEN_1: switch (mode & (_O_RDONLY | _O_TEXT | _O_BINARY | _O_WRONLY)) { case _O_WRONLY | _O_TEXT: // Case for writing to child Stdin in text mode. fd1 = _open_osfhandle((INT_PTR)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "w"); f = PyFile_FromFile(f1, cmdstring, "w", _PyPclose); PyFile_SetBufSize(f, 0); // We don't care about these pipes anymore, so close them. CloseHandle(hChildStdoutRdDup); CloseHandle(hChildStderrRdDup); break; case _O_RDONLY | _O_TEXT: // Case for reading from child Stdout in text mode. fd1 = _open_osfhandle((INT_PTR)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "r"); f = PyFile_FromFile(f1, cmdstring, "r", _PyPclose); PyFile_SetBufSize(f, 0); // We don't care about these pipes anymore, so close them. CloseHandle(hChildStdinWrDup); CloseHandle(hChildStderrRdDup); break; case _O_RDONLY | _O_BINARY: // Case for readinig from child Stdout in binary mode. fd1 = _open_osfhandle((INT_PTR)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "rb"); f = PyFile_FromFile(f1, cmdstring, "rb", _PyPclose); PyFile_SetBufSize(f, 0); // We don't care about these pipes anymore, so close them. CloseHandle(hChildStdinWrDup); CloseHandle(hChildStderrRdDup); break; case _O_WRONLY | _O_BINARY: // Case for writing to child Stdin in binary mode. fd1 = _open_osfhandle((INT_PTR)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "wb"); f = PyFile_FromFile(f1, cmdstring, "wb", _PyPclose); PyFile_SetBufSize(f, 0); // We don't care about these pipes anymore, so close them. CloseHandle(hChildStdoutRdDup); CloseHandle(hChildStderrRdDup); break; } file_count = 1; break; case POPEN_2: case POPEN_4: { char *m1, *m2; PyObject *p1, *p2; if (mode & _O_TEXT) { m1="r"; m2="w"; } else { m1="rb"; m2="wb"; } fd1 = _open_osfhandle((INT_PTR)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); fd2 = _open_osfhandle((INT_PTR)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose); PyFile_SetBufSize(p1, 0); p2 = PyFile_FromFile(f2, cmdstring, m1, _PyPclose); PyFile_SetBufSize(p2, 0); if (n != 4) CloseHandle(hChildStderrRdDup); f = Py_BuildValue("OO",p1,p2); Py_XDECREF(p1); Py_XDECREF(p2); file_count = 2; break; } case POPEN_3: { char *m1, *m2; PyObject *p1, *p2, *p3; if (mode & _O_TEXT) { m1="r"; m2="w"; } else { m1="rb"; m2="wb"; } fd1 = _open_osfhandle((INT_PTR)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); fd2 = _open_osfhandle((INT_PTR)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); fd3 = _open_osfhandle((INT_PTR)hChildStderrRdDup, mode); f3 = _fdopen(fd3, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose); p2 = PyFile_FromFile(f2, cmdstring, m1, _PyPclose); p3 = PyFile_FromFile(f3, cmdstring, m1, _PyPclose); PyFile_SetBufSize(p1, 0); PyFile_SetBufSize(p2, 0); PyFile_SetBufSize(p3, 0); f = Py_BuildValue("OOO",p1,p2,p3); Py_XDECREF(p1); Py_XDECREF(p2); Py_XDECREF(p3); file_count = 3; break; } } if (n == POPEN_4) { if (!_PyPopenCreateProcess(cmdstring, hChildStdinRd, hChildStdoutWr, hChildStdoutWr, &hProcess)) return PyWin_SetAPIError("CreateProcess"); } else { if (!_PyPopenCreateProcess(cmdstring, hChildStdinRd, hChildStdoutWr, hChildStderrWr, &hProcess)) return PyWin_SetAPIError("CreateProcess"); } /* * Insert the files we've created into the process dictionary * all referencing the list with the process handle and the * initial number of files (see description below in _PyPclose). * Since if _PyPclose later tried to wait on a process when all * handles weren't closed, it could create a deadlock with the * child, we spend some energy here to try to ensure that we * either insert all file handles into the dictionary or none * at all. It's a little clumsy with the various popen modes * and variable number of files involved. */ if (!_PyPopenProcs) { _PyPopenProcs = PyDict_New(); } if (_PyPopenProcs) { PyObject *procObj, *hProcessObj, *intObj, *fileObj[3]; int ins_rc[3]; fileObj[0] = fileObj[1] = fileObj[2] = NULL; ins_rc[0] = ins_rc[1] = ins_rc[2] = 0; procObj = PyList_New(2); hProcessObj = PyLong_FromVoidPtr(hProcess); intObj = PyInt_FromLong(file_count); if (procObj && hProcessObj && intObj) { PyList_SetItem(procObj,0,hProcessObj); PyList_SetItem(procObj,1,intObj); fileObj[0] = PyLong_FromVoidPtr(f1); if (fileObj[0]) { ins_rc[0] = PyDict_SetItem(_PyPopenProcs, fileObj[0], procObj); } if (file_count >= 2) { fileObj[1] = PyLong_FromVoidPtr(f2); if (fileObj[1]) { ins_rc[1] = PyDict_SetItem(_PyPopenProcs, fileObj[1], procObj); } } if (file_count >= 3) { fileObj[2] = PyLong_FromVoidPtr(f3); if (fileObj[2]) { ins_rc[2] = PyDict_SetItem(_PyPopenProcs, fileObj[2], procObj); } } if (ins_rc[0] < 0 || !fileObj[0] || ins_rc[1] < 0 || (file_count > 1 && !fileObj[1]) || ins_rc[2] < 0 || (file_count > 2 && !fileObj[2])) { /* Something failed - remove any dictionary * entries that did make it. */ if (!ins_rc[0] && fileObj[0]) { PyDict_DelItem(_PyPopenProcs, fileObj[0]); } if (!ins_rc[1] && fileObj[1]) { PyDict_DelItem(_PyPopenProcs, fileObj[1]); } if (!ins_rc[2] && fileObj[2]) { PyDict_DelItem(_PyPopenProcs, fileObj[2]); } } } /* * Clean up our localized references for the dictionary keys * and value since PyDict_SetItem will Py_INCREF any copies * that got placed in the dictionary. */ Py_XDECREF(procObj); Py_XDECREF(fileObj[0]); Py_XDECREF(fileObj[1]); Py_XDECREF(fileObj[2]); } // Child is launched. Close the parents copy of those pipe handles // that only the child should have open. // You need to make sure that no handles to the write end of the // output pipe are maintained in this process or else the pipe will // not close when the child process exits and the ReadFile will hang. if (!CloseHandle(hChildStdinRd)) return PyWin_SetAPIError("CloseHandle"); if (!CloseHandle(hChildStdoutWr)) return PyWin_SetAPIError("CloseHandle"); if ((n != 4) && (!CloseHandle(hChildStderrWr))) return PyWin_SetAPIError("CloseHandle"); return f; }