changes from remarks.

- removing custom code out of `fcntl.fcntl`.
- F_GETPATH requires MAXPATHLEN or greater so we increase the buffer size
to be able to cater with F_KINFO greater size.
- `fcntl.kinfoalloc` preallocate a proper kinfo_file buffer.
- `fcntl.kinfodict` returns a handy representation of the data.

Author: devnexen

Doc/whatsnew/3.13.rst

@@ -212,6 +212,11 @@ email
   (Contributed by Thomas Dwyer and Victor Stinner for :gh:`102988` to improve
   the CVE-2023-27043 fix.)
 
+fcntl
+-----
+
+* Added constant :data:`fcntl.F_KINFO`
+
 fractions
 ---------
 

Lib/test/test_fcntl.py

@@ -196,9 +196,11 @@ def test_fcntl_f_getpath(self):
     @unittest.skipUnless(sys.platform.startswith("freebsd") and hasattr(fcntl, "F_KINFO"), "F_KINFO is only available on freebsd")
     def test_fcntl_f_kinfo(self):
         self.f = open(TESTFN, 'wb')
+        buffer = fcntl.kinfoalloc()
         expected = os.path.abspath(TESTFN).encode('utf-8')
-        res = fcntl.fcntl(self.f.fileno(), fcntl.F_KINFO)
-        self.assertEqual(expected, res)
+        res = fcntl.fcntl(self.f.fileno(), fcntl.F_KINFO, buffer)
+        path = fcntl.kinfodict(res)["path"]
+        self.assertEqual(expected, path)
 
     @unittest.skipUnless(
         hasattr(fcntl, "F_SETPIPE_SZ") and hasattr(fcntl, "F_GETPIPE_SZ"),

Modules/clinic/fcntlmodule.c.h

@@ -59,7 +59,6 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
     int ret;
     char *str;
     Py_ssize_t len;
-    char buf[1024];
     int async_err = 0;
 
     if (PySys_Audit("fcntl.fcntl", "iiO", fd, code, arg ? arg : Py_None) < 0) {
@@ -68,20 +67,15 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
 
     if (arg != NULL) {
         int parse_result;
-#ifdef F_KINFO
-	if (code == F_KINFO) {
-		PyErr_SetString(PyExc_ValueError,
-				"fcntl arg not permitted with F_KINFO");
-	}
-#endif
 
         if (PyArg_Parse(arg, "s#", &str, &len)) {
+            char buf[4096];
             if ((size_t)len > sizeof buf) {
                 PyErr_SetString(PyExc_ValueError,
                                 "fcntl string arg too long");
                 return NULL;
             }
-            memcpy(buf, str, len);
+	    memcpy(buf, str, len);
             do {
                 Py_BEGIN_ALLOW_THREADS
                 ret = fcntl(fd, code, buf);
@@ -103,21 +97,6 @@ fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
         }
     }
 
-#ifdef F_KINFO
-    if (code == F_KINFO) {
-        struct kinfo_file f = {.kf_structsize = KINFO_FILE_SIZE};
-        do {
-            Py_BEGIN_ALLOW_THREADS
-            ret = fcntl(fd, code, &f);
-            Py_END_ALLOW_THREADS
-        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
-        if (ret < 0) {
-            return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
-        }
-	return PyBytes_FromString(f.kf_path);
-    }
-#endif
-
     do {
         Py_BEGIN_ALLOW_THREADS
         ret = fcntl(fd, code, (int)int_arg);
@@ -463,13 +442,70 @@ fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
     Py_RETURN_NONE;
 }
 
+#ifdef F_KINFO
+/*[clinic input]
+fcntl.kinfoalloc
+
+Return a FreeBSD's kinfo_file buffer with the `kf_structsize` field pre-initialised.
+
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_kinfoalloc_impl(PyObject *module)
+/*[clinic end generated code: output=c61603aeb3d91a0e input=28e2e82cc296f82c]*/
+{
+    char buf[KINFO_FILE_SIZE + 1]; 
+    ((struct kinfo_file *)buf)->kf_structsize = KINFO_FILE_SIZE;
+    return PyBytes_FromStringAndSize(buf, KINFO_FILE_SIZE);
+}
+
+/*[clinic input]
+fcntl.kinfodict
+
+    arg: object(c_default='NULL') = 0
+    /
+
+Return a FreeBSD's kinfo_file as dictionary.
+
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_kinfodict_impl(PyObject *module, PyObject *arg)
+/*[clinic end generated code: output=3873ae40aeac8e7f input=faba1f2ce099752f]*/
+{
+	PyObject *dict;
+
+	if (PySys_Audit("fcntl.kinfodict", "O", arg) < 0 || arg == NULL) {
+		return NULL;
+	}
+
+	dict = PyDict_New();
+	if (dict) {
+		struct kinfo_file *kf;
+		kf = (struct kinfo_file *)PyBytes_AsString(arg);
+
+		PyDict_SetItemString(dict, "status", PyLong_FromLong(kf->kf_status));
+		PyDict_SetItemString(dict, "type", PyLong_FromLong(kf->kf_type));
+		PyDict_SetItemString(dict, "offset", PyLong_FromLongLong(kf->kf_offset));
+		PyDict_SetItemString(dict, "path", PyBytes_FromString(kf->kf_path));
+		return dict;
+	}
+
+	PyErr_SetString(PyExc_ValueError, "fcntl.kinfodict could not create its dictionary");
+	return NULL;
+}
+
+#endif
+
 /* List of functions */
 
 static PyMethodDef fcntl_methods[] = {
     FCNTL_FCNTL_METHODDEF
     FCNTL_IOCTL_METHODDEF
     FCNTL_FLOCK_METHODDEF
     FCNTL_LOCKF_METHODDEF
+    FCNTL_KINFOALLOC_METHODDEF
+    FCNTL_KINFODICT_METHODDEF
     {NULL, NULL}  /* sentinel */
 };