From 76621c7d2388d877fad0bdbb98eb11e0d1c2d8e1 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Oct 06 2021 03:41:55 +0000 Subject: import pyparted-3.11.7-4.el8 --- diff --git a/.gitignore b/.gitignore index e632db0..12b265d 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1 @@ -SOURCES/pyparted-3.11.0.tar.gz +SOURCES/pyparted-3.11.7.tar.gz diff --git a/.pyparted.metadata b/.pyparted.metadata index d25f4f9..a9037d1 100644 --- a/.pyparted.metadata +++ b/.pyparted.metadata @@ -1 +1 @@ -9c28f947ed6b13ee85326160964881f1bf60def0 SOURCES/pyparted-3.11.0.tar.gz +8084cb0b64542e57066716505fa4f1d28c031b09 SOURCES/pyparted-3.11.7.tar.gz diff --git a/SOURCES/pyparted-3.11.7-covscan.patch b/SOURCES/pyparted-3.11.7-covscan.patch new file mode 100644 index 0000000..afcb48b --- /dev/null +++ b/SOURCES/pyparted-3.11.7-covscan.patch @@ -0,0 +1,1552 @@ +diff -up pyparted-3.11.7/src/pydisk.c.orig pyparted-3.11.7/src/pydisk.c +--- pyparted-3.11.7/src/pydisk.c.orig 2019-04-23 14:23:44.456665800 -0400 ++++ pyparted-3.11.7/src/pydisk.c 2021-07-09 15:59:00.998981206 -0400 +@@ -205,8 +205,7 @@ int _ped_Partition_init(_ped_Partition * + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); + } + } else { +@@ -423,8 +422,7 @@ int _ped_Disk_init(_ped_Disk *self, PyOb + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(DiskLabelException, partedExnMessage); + } + } else { +@@ -548,6 +546,7 @@ PyObject *py_ped_disk_type_get_next(PyOb + } + + next = ped_disk_type_get_next(cur); ++ + if (next) { + ret = PedDiskType2_ped_DiskType(next); + return (PyObject *) ret; +@@ -575,6 +574,7 @@ PyObject *py_ped_disk_type_get(PyObject + } + + ret = PedDiskType2_ped_DiskType(out_type); ++ + if (ret == NULL) { + return NULL; + } +@@ -590,16 +590,14 @@ PyObject *py_ped_disk_type_check_feature + int ret = 0; + + if (!PyArg_ParseTuple(args, "i", &feature)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disktype = _ped_DiskType2PedDiskType(s); ++ + if (disktype) { + ret = ped_disk_type_check_feature(disktype, feature); + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -613,29 +611,28 @@ PyObject *py_ped_disk_clobber(PyObject * + int ret = 0; + + device = _ped_Device2PedDevice(s); +- if (device == NULL) +- return NULL; ++ ++ if (device == NULL) { ++ return (PyObject *) NULL; ++ } + + ret = ped_disk_clobber(device); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(DiskException, "Failed to clobber partition table on device %s", device->path); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + +- if (ret) { +- Py_RETURN_TRUE; +- } else { +- Py_RETURN_FALSE; +- } ++ Py_RETURN_TRUE; + } + + /* XXX: is this necessary? */ +@@ -644,18 +641,20 @@ PyObject *py_ped_disk_duplicate(PyObject + _ped_Disk *ret = NULL; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + pass_disk = ped_disk_duplicate(disk); ++ + if (pass_disk == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(DiskException, "Could not duplicate device %s", disk->dev->path); ++ } + + return NULL; + } +@@ -664,8 +663,7 @@ PyObject *py_ped_disk_duplicate(PyObject + if (ret == NULL) { + return NULL; + } +- } +- else { ++ } else { + return NULL; + } + +@@ -685,8 +683,9 @@ PyObject *py_ped_disk_destroy(PyObject * + PedDisk *disk = NULL; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + ped_disk_destroy(disk); +@@ -701,26 +700,24 @@ PyObject *py_ped_disk_commit(PyObject *s + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_commit(disk); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); ++ } ++ } else { ++ PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", disk->dev->path, __func__); + } +- else +- PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", +- disk->dev->path, __func__); + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -734,26 +731,24 @@ PyObject *py_ped_disk_commit_to_dev(PyOb + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_commit_to_dev(disk); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); ++ } ++ } else { ++ PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", disk->dev->path, __func__); + } +- else +- PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", +- disk->dev->path, __func__); + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -773,20 +768,16 @@ PyObject *py_ped_disk_commit_to_os(PyObj + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); ++ } ++ } else { ++ PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", disk->dev->path, __func__); + } +- else +- PyErr_Format(DiskException, "Could not commit to disk %s, (%s)", +- disk->dev->path, __func__); + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -800,25 +791,24 @@ PyObject *py_ped_disk_check(PyObject *s, + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_check(disk); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(IOException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(DiskException, "Could not check disk %s", disk->dev->path); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -831,12 +821,10 @@ PyObject *py_ped_disk_print(PyObject *s, + PedDisk *disk = NULL; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ped_disk_print(disk); + } +- else { +- return NULL; +- } + + Py_INCREF(Py_None); + return Py_None; +@@ -847,12 +835,10 @@ PyObject *py_ped_disk_get_primary_partit + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_get_primary_partition_count(disk); + } +- else { +- return NULL; +- } + + return PyLong_FromLong(ret); + } +@@ -862,38 +848,33 @@ PyObject *py_ped_disk_get_last_partition + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_get_last_partition_num(disk); + } +- else { +- return NULL; +- } + + return PyLong_FromLong(ret); + } + +-PyObject *py_ped_disk_get_max_primary_partition_count(PyObject *s, +- PyObject *args) { ++PyObject *py_ped_disk_get_max_primary_partition_count(PyObject *s, PyObject *args) { + PedDisk *disk = NULL; + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_get_max_primary_partition_count(disk); + } +- else { +- return NULL; +- } + + return PyLong_FromLong(ret); + } + +-PyObject *py_ped_disk_get_max_supported_partition_count(PyObject *s, +- PyObject *args) { ++PyObject *py_ped_disk_get_max_supported_partition_count(PyObject *s, PyObject *args) { + PedDisk *disk = NULL; + int max = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + if (ped_disk_get_max_supported_partition_count(disk, &max) == true) { + return Py_BuildValue("i", max); +@@ -910,13 +891,16 @@ PyObject *py_ped_disk_get_partition_alig + _ped_Alignment *ret = NULL; + + disk = _ped_Disk2PedDisk(s); +- if (!disk) +- return NULL; ++ ++ if (!disk) { ++ return (PyObject *) NULL; ++ } + + alignment = ped_disk_get_partition_alignment(disk); ++ + if (!alignment) { + PyErr_SetString(CreateException, "Could not get alignment for device"); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedAlignment2_ped_Alignment(alignment); +@@ -929,8 +913,10 @@ PyObject *py_ped_disk_max_partition_leng + PedDisk *disk = NULL; + + disk = _ped_Disk2PedDisk(s); +- if (!disk) +- return NULL; ++ ++ if (!disk) { ++ return (PyObject *) NULL; ++ } + + return PyLong_FromUnsignedLongLong(ped_disk_max_partition_length(disk)); + } +@@ -939,8 +925,10 @@ PyObject *py_ped_disk_max_partition_star + PedDisk *disk = NULL; + + disk = _ped_Disk2PedDisk(s); +- if (!disk) +- return NULL; ++ ++ if (!disk) { ++ return (PyObject *) NULL; ++ } + + return PyLong_FromUnsignedLongLong(ped_disk_max_partition_start_sector(disk)); + } +@@ -950,27 +938,29 @@ PyObject *py_ped_disk_set_flag(PyObject + PedDisk *disk = NULL; + + if (!PyArg_ParseTuple(args, "ii", &flag, &state)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + ret = ped_disk_set_flag(disk, flag, state); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(DiskException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(DiskException, "Could not set flag on disk %s", disk->dev->path); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + Py_RETURN_TRUE; +@@ -981,12 +971,13 @@ PyObject *py_ped_disk_get_flag(PyObject + PedDisk *disk = NULL; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (ped_disk_get_flag(disk, flag)) { +@@ -1001,12 +992,13 @@ PyObject *py_ped_disk_is_flag_available( + PedDisk *disk = NULL; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (ped_disk_is_flag_available(disk, flag)) { +@@ -1021,27 +1013,28 @@ PyObject *py_ped_disk_flag_get_name(PyOb + char *ret = NULL; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (flag < PED_DISK_FIRST_FLAG) { + PyErr_SetString(PyExc_ValueError, "Invalid flag provided."); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = (char *) ped_disk_flag_get_name(flag); ++ + if (ret == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(DiskException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(DiskException, "Could not get disk flag name for %d", flag); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + return PyUnicode_FromString(ret); +@@ -1051,7 +1044,7 @@ PyObject *py_ped_disk_flag_get_by_name(P + char *name = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) { +- return NULL; ++ return (PyObject *) NULL; + } + + return PyLong_FromLong(ped_disk_flag_get_by_name(name)); +@@ -1061,7 +1054,7 @@ PyObject *py_ped_disk_flag_next(PyObject + int flag; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + return Py_BuildValue("i", ped_disk_flag_next(flag)); +@@ -1080,8 +1073,9 @@ PyObject *py_ped_partition_destroy(_ped_ + PedPartition *partition = NULL; + + partition = _ped_Partition2PedPartition(s); ++ + if (partition == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + ped_partition_destroy(partition); +@@ -1096,12 +1090,10 @@ PyObject *py_ped_partition_is_active(_pe + int ret = 0; + + partition = _ped_Partition2PedPartition(s); ++ + if (partition) { + ret = ped_partition_is_active(partition); + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -1117,28 +1109,30 @@ PyObject *py_ped_partition_set_flag(_ped + int ret = 0; + + if (!PyArg_ParseTuple(args, "ii", &flag, &in_state)) { +- return NULL; ++ return (PyObject *) NULL; + } + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (part && flag && in_state > -1) { + ret = ped_partition_set_flag(part, flag, in_state); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not set flag on partition %s%d", part->disk->dev->path, part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + } + +@@ -1155,18 +1149,19 @@ PyObject *py_ped_partition_get_flag(_ped + int ret = -1; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + /* ped_partition_get_flag will assert on this. */ + if (!ped_partition_is_active(part)) { + PyErr_Format(PartitionException, "Could not get flag on inactive partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = ped_partition_get_flag(part, flag); +@@ -1184,17 +1179,18 @@ PyObject *py_ped_partition_is_flag_avail + int ret = 0; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (!ped_partition_is_active(part)) { + PyErr_Format(PartitionException, "Flag is not available on inactive partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = ped_partition_is_flag_available(part, flag); +@@ -1213,31 +1209,34 @@ PyObject *py_ped_partition_set_system(_p + int ret = 0; + + if (!PyArg_ParseTuple(args, "O!", &_ped_FileSystemType_Type_obj, &in_fstype)) { +- return NULL; ++ return (PyObject *) NULL; + } + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_fstype != NULL) { + out_fstype = _ped_FileSystemType2PedFileSystemType(in_fstype); ++ + if (out_fstype == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + } + + /* ped_partition_set_system will assert on this. */ + if (!ped_partition_is_active(part)) { + PyErr_Format(PartitionException, "Could not set system flag on inactive partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = ped_partition_set_system(part, out_fstype); ++ + if (ret == 0) { + PyErr_Format(PartitionException, "Could not set system flag on partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + if (ret) { +@@ -1253,34 +1252,35 @@ PyObject *py_ped_partition_set_name(_ped + int ret = 0; + + if (!PyArg_ParseTuple(args, "s", &in_name)) { +- return NULL; ++ return (PyObject *) NULL; + } + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + /* ped_partition_set_name will assert on this. */ + if (!ped_partition_is_active(part)) { + PyErr_Format(PartitionException, "Could not set system flag on inactive partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = ped_partition_set_name(part, in_name); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); + } + } else { + PyErr_Format(PartitionException, "Could not set name on partition %s%d", part->disk->dev->path, part->num); + } + +- return NULL; ++ return (PyObject *) NULL; + } + + if (ret) { +@@ -1295,30 +1295,31 @@ PyObject *py_ped_partition_get_name(_ped + char *ret = NULL; + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + /* ped_partition_get_name will assert on this. */ + if (!ped_partition_is_active(part)) { + PyErr_Format(PartitionException, "Could not get name on inactive partition %s%d", part->disk->dev->path, part->num); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = (char *) ped_partition_get_name(part); ++ + if (ret == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); + } + } else { + PyErr_Format(PartitionException, "Could not read name on partition %s%d", part->disk->dev->path, part->num); + } + +- return NULL; ++ return (PyObject *) NULL; + } + + return PyUnicode_FromString(ret); +@@ -1329,13 +1330,13 @@ PyObject *py_ped_partition_is_busy(_ped_ + int ret = 0; + + part = _ped_Partition2PedPartition(s); +- if (part) { +- ret = ped_partition_is_busy(part); +- } +- else { +- return NULL; ++ ++ if (part == NULL) { ++ return (PyObject *) NULL; + } + ++ ret = ped_partition_is_busy(part); ++ + if (ret) { + Py_RETURN_TRUE; + } else { +@@ -1348,15 +1349,16 @@ PyObject *py_ped_partition_get_path(_ped + char *ret = NULL; + + part = _ped_Partition2PedPartition(s); +- if (part) { +- ret = ped_partition_get_path(part); +- if (ret == NULL) { +- PyErr_Format(PartitionException, "Could not get path for partition %s%d", part->disk->dev->path, part->num); +- return NULL; +- } ++ ++ if (part == NULL) { ++ return (PyObject *) NULL; + } +- else { +- return NULL; ++ ++ ret = ped_partition_get_path(part); ++ ++ if (ret == NULL) { ++ PyErr_Format(PartitionException, "Could not get path for partition %s%d", part->disk->dev->path, part->num); ++ return (PyObject *) NULL; + } + + return PyUnicode_FromString(ret); +@@ -1366,12 +1368,12 @@ PyObject *py_ped_partition_reset_num(_pe + PedPartition *part = NULL; + + part = _ped_Partition2PedPartition(s); ++ + if (part == NULL) { +- Py_RETURN_FALSE; ++ return (PyObject *) NULL; + } + + part->num = -1; +- + Py_RETURN_TRUE; + } + +@@ -1381,17 +1383,18 @@ PyObject *py_ped_partition_type_get_name + char *ret = NULL; + + if (!PyArg_ParseTuple(args, "i", &type)) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (type) { + ret = (char *) ped_partition_type_get_name(type); + } + +- if (ret != NULL) ++ if (ret != NULL) { + return PyUnicode_FromString(ret); +- else +- return PyUnicode_FromString(""); ++ } else { ++ return (PyObject *) NULL; ++ } + } + + PyObject *py_ped_partition_flag_get_name(PyObject *s, PyObject *args) { +@@ -1399,12 +1402,12 @@ PyObject *py_ped_partition_flag_get_name + char *ret = NULL; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (flag < PED_PARTITION_FIRST_FLAG) { + PyErr_SetString(PyExc_ValueError, "Invalid flag provided."); +- return NULL; ++ return (PyObject *) NULL; + } + + if (flag) { +@@ -1413,7 +1416,7 @@ PyObject *py_ped_partition_flag_get_name + if (!ret) { + /* Re-raise the libparted exception. */ + partedExnRaised = 0; +- return NULL; ++ return (PyObject *) NULL; + } + } + +@@ -1424,7 +1427,7 @@ PyObject *py_ped_partition_flag_get_by_n + char *name = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) { +- return NULL; ++ return (PyObject *) NULL; + } + + return PyLong_FromLong(ped_partition_flag_get_by_name(name)); +@@ -1434,7 +1437,7 @@ PyObject *py_ped_partition_flag_next(PyO + int flag; + + if (!PyArg_ParseTuple(args, "i", &flag)) { +- return NULL; ++ return (PyObject *) NULL; + } + + return Py_BuildValue("i", ped_partition_flag_next(flag)); +@@ -1448,38 +1451,40 @@ PyObject *py_ped_disk_add_partition(PyOb + PedConstraint *out_constraint = NULL; + int ret = 0; + +- if (!PyArg_ParseTuple(args, "O!|O!",&_ped_Partition_Type_obj, +- &in_part, &_ped_Constraint_Type_obj, &in_constraint)) { +- return NULL; ++ if (!PyArg_ParseTuple(args, "O!|O!",&_ped_Partition_Type_obj, &in_part, &_ped_Constraint_Type_obj, &in_constraint)) { ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + /* Its non-sense to add an owned partition */ + if (in_part->_owned == 1) { + PyErr_SetString(PartitionException, "Attempting to add a partition " + "that is already owned by a disk."); +- return NULL; ++ return (PyObject *) NULL; + } + + + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "Cannot add a partition to another disk then the one used for creating the partition"); +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_constraint) { + out_constraint = _ped_Constraint2PedConstraint(in_constraint); ++ + if (out_constraint == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + } + +@@ -1492,14 +1497,14 @@ PyObject *py_ped_disk_add_partition(PyOb + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not create partition %s%d", out_part->disk->dev->path, out_part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + /* update our _ped.Partition object with out_part values */ +@@ -1521,56 +1526,62 @@ PyObject *py_ped_disk_remove_partition(P + int ret = 0; + + if (!PyArg_ParseTuple(args, "O!", &_ped_Partition_Type_obj, &in_part)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + /* Its non-sense to remove an unowned partition */ + if (in_part->_owned == 0) { + PyErr_SetString(PartitionException, "Attempting to remove a partition " + "that is not owned by any disk."); +- return NULL; ++ return (PyObject *) NULL; + } + + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "Partition is not part of the disk it is being removed from"); +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->part_list != NULL) { + PedPartition *part; ++ + for (part = out_part->part_list; part; part = part->next) { +- if (ped_partition_is_active(part)) ++ if (ped_partition_is_active(part)) { + break; ++ } + } ++ + if (part) { + PyErr_SetString(PartitionException, "Attempting to remove an extended partition that still contains logical partitions"); +- return NULL; ++ return (PyObject *) NULL; + } + } + + ret = ped_disk_remove_partition(disk, out_part); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not remove partition %s%d", out_part->disk->dev->path, out_part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + in_part->_owned = 0; +@@ -1591,25 +1602,24 @@ PyObject *py_ped_disk_delete_all(PyObjec + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_delete_all(disk); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not remove all partitions on %s", disk->dev->path); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -1627,57 +1637,58 @@ PyObject *py_ped_disk_set_partition_geom + PedSector start, end; + int ret = 0; + +- if (!PyArg_ParseTuple(args, "O!OLL", &_ped_Partition_Type_obj, &in_part, +- &in_constraint, &start, &end)) { +- return NULL; ++ if (!PyArg_ParseTuple(args, "O!OLL", &_ped_Partition_Type_obj, &in_part, &in_constraint, &start, &end)) { ++ return (PyObject *) NULL; + } + +- if (in_constraint != Py_None && !PyObject_IsInstance(in_constraint, +- (PyObject *)&_ped_Constraint_Type_obj)) { ++ if (in_constraint != Py_None && !PyObject_IsInstance(in_constraint, (PyObject *)&_ped_Constraint_Type_obj)) { + PyErr_SetString(PyExc_ValueError, "invalid constraint type"); +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "partition.disk does not match disk"); +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_constraint != Py_None) { + out_constraint = _ped_Constraint2PedConstraint(in_constraint); ++ + if (out_constraint == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + } + +- ret = ped_disk_set_partition_geom(disk, out_part, out_constraint, +- start, end); ++ ret = ped_disk_set_partition_geom(disk, out_part, out_constraint, start, end); + +- if (out_constraint) ++ if (out_constraint) { + ped_constraint_destroy(out_constraint); ++ } + + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not set geometry on %s%d", disk->dev->path, out_part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + *((_ped_Geometry *)in_part->geom)->ped_geometry = out_part->geom; +@@ -1697,50 +1708,53 @@ PyObject *py_ped_disk_maximize_partition + PedConstraint *out_constraint = NULL; + int ret = 0; + +- if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part, +- &_ped_Constraint_Type_obj, &in_constraint)) { +- return NULL; ++ if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part, &_ped_Constraint_Type_obj, &in_constraint)) { ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "partition.disk does not match disk"); +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_constraint) { + out_constraint = _ped_Constraint2PedConstraint(in_constraint); ++ + if (out_constraint == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + } + + ret = ped_disk_maximize_partition(disk, out_part, out_constraint); + +- if (out_constraint) ++ if (out_constraint) { + ped_constraint_destroy(out_constraint); ++ } + + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not maximize partition size for %s%d", disk->dev->path, out_part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + *((_ped_Geometry *)in_part->geom)->ped_geometry = out_part->geom; +@@ -1761,55 +1775,59 @@ PyObject *py_ped_disk_get_max_partition_ + PedGeometry *pass_geom = NULL; + _ped_Geometry *ret = NULL; + +- if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part, +- &_ped_Constraint_Type_obj, &in_constraint)) { +- return NULL; ++ if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part, &_ped_Constraint_Type_obj, &in_constraint)) { ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "partition.disk does not match disk"); +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_constraint) { + out_constraint = _ped_Constraint2PedConstraint(in_constraint); ++ + if (out_constraint == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + } + + pass_geom = ped_disk_get_max_partition_geometry(disk, out_part, + out_constraint); +- if (out_constraint) ++ if (out_constraint) { + ped_constraint_destroy(out_constraint); ++ } + + if (pass_geom == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not get maximum partition size for %s%d", disk->dev->path, out_part->num); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedGeometry2_ped_Geometry(pass_geom); ++ + if (ret == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + return (PyObject *) ret; +@@ -1820,25 +1838,24 @@ PyObject *py_ped_disk_minimize_extended_ + int ret = 0; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + ret = ped_disk_minimize_extended_partition(disk); ++ + if (ret == 0) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(PartitionException, partedExnMessage); +- } +- else ++ } ++ } else { + PyErr_Format(PartitionException, "Could not shrink extended partition on %s", disk->dev->path); ++ } + +- return NULL; ++ return (PyObject *) NULL; + } + } +- else { +- return NULL; +- } + + if (ret) { + Py_RETURN_TRUE; +@@ -1855,38 +1872,41 @@ PyObject *py_ped_disk_next_partition(PyO + _ped_Partition *ret = NULL; + + if (!PyArg_ParseTuple(args, "|O!", &_ped_Partition_Type_obj, &in_part)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (in_part) { + out_part = _ped_Partition2PedPartition(in_part); ++ + if (out_part == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if (out_part->disk != disk) { + PyErr_SetString(PartitionException, "partition.disk does not match disk"); +- return NULL; ++ return (PyObject *) NULL; + } + } + + pass_part = ped_disk_next_partition(disk, out_part); ++ + if (pass_part == NULL) { + Py_INCREF(Py_None); + return Py_None; + } + + ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s); +- if (ret == NULL) { +- return NULL; ++ ++ if (ret != NULL) { ++ ret->_owned = 1; + } + +- ret->_owned = 1; + return (PyObject *) ret; + } + +@@ -1897,27 +1917,28 @@ PyObject *py_ped_disk_get_partition(PyOb + _ped_Partition *ret = NULL; + + if (!PyArg_ParseTuple(args, "i", &num)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + pass_part = ped_disk_get_partition(disk, num); ++ + if (pass_part == NULL) { + PyErr_SetString(PartitionException, "Partition does not exist"); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s); ++ + if (ret == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } +- } +- else { +- return NULL; ++ ++ ret->_owned = 1; + } + +- ret->_owned = 1; + return (PyObject *) ret; + } + +@@ -1928,23 +1949,26 @@ PyObject *py_ped_disk_get_partition_by_s + _ped_Partition *ret = NULL; + + if (!PyArg_ParseTuple(args, "L", §or)) { +- return NULL; ++ return (PyObject *) NULL; + } + + disk = _ped_Disk2PedDisk(s); ++ + if (disk == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + pass_part = ped_disk_get_partition_by_sector(disk, sector); ++ + if (pass_part == NULL) { + PyErr_SetString(PartitionException, "Partition does not exist"); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s); ++ + if (ret == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + ret->_owned = 1; +@@ -1957,23 +1981,24 @@ PyObject *py_ped_disk_extended_partition + _ped_Partition *ret = NULL; + + disk = _ped_Disk2PedDisk(s); ++ + if (disk) { + pass_part = ped_disk_extended_partition(disk); ++ + if (pass_part == NULL) { + PyErr_SetString(PartitionException, "Extended partition does not exist"); +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s); ++ + if (ret == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } +- } +- else { +- return NULL; ++ ++ ret->_owned = 1; + } + +- ret->_owned = 1; + return (PyObject *) ret; + } + +@@ -1985,26 +2010,25 @@ PyObject *py_ped_disk_new_fresh(PyObject + PedDisk *disk = NULL; + _ped_Disk *ret = NULL; + +- if (!PyArg_ParseTuple(args, "O!O!", &_ped_Device_Type_obj, &in_device, +- &_ped_DiskType_Type_obj, &in_type)) { +- return NULL; ++ if (!PyArg_ParseTuple(args, "O!O!", &_ped_Device_Type_obj, &in_device, &_ped_DiskType_Type_obj, &in_type)) { ++ return (PyObject *) NULL; + } + + if ((device = _ped_Device2PedDevice((PyObject *) in_device)) == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if ((type = _ped_DiskType2PedDiskType((PyObject *) in_type)) == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if ((disk = ped_disk_new_fresh(device, type)) == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(DiskException, partedExnMessage); ++ } + } else { + if (disk->dev == NULL) { + PyErr_Format(DiskException, "Could not create new disk label"); +@@ -2013,7 +2037,7 @@ PyObject *py_ped_disk_new_fresh(PyObject + } + } + +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedDisk2_ped_Disk(disk); +@@ -2027,20 +2051,20 @@ PyObject *py_ped_disk_new(PyObject *s, P + _ped_Disk *ret = NULL; + + if (!PyArg_ParseTuple(args, "O!", &_ped_Device_Type_obj, &in_device)) { +- return NULL; ++ return (PyObject *) NULL; + } + + if ((device = _ped_Device2PedDevice((PyObject *) in_device)) == NULL) { +- return NULL; ++ return (PyObject *) NULL; + } + + if ((disk = ped_disk_new(device)) == NULL) { + if (partedExnRaised) { + partedExnRaised = 0; + +- if (!PyErr_ExceptionMatches(PartedException) && +- !PyErr_ExceptionMatches(PyExc_NotImplementedError)) ++ if (!PyErr_ExceptionMatches(PartedException) && !PyErr_ExceptionMatches(PyExc_NotImplementedError)) { + PyErr_SetString(DiskException, partedExnMessage); ++ } + } else { + if (disk->dev == NULL) { + PyErr_Format(DiskException, "Could not create new disk label"); +@@ -2049,7 +2073,7 @@ PyObject *py_ped_disk_new(PyObject *s, P + } + } + +- return NULL; ++ return (PyObject *) NULL; + } + + ret = PedDisk2_ped_Disk(disk); +diff -up pyparted-3.11.7/src/pytimer.c.orig pyparted-3.11.7/src/pytimer.c +--- pyparted-3.11.7/src/pytimer.c.orig 2019-04-23 14:24:26.657517400 -0400 ++++ pyparted-3.11.7/src/pytimer.c 2021-07-09 15:09:17.827164706 -0400 +@@ -104,33 +104,9 @@ int _ped_Timer_clear(_ped_Timer *self) { + } + + int _ped_Timer_init(_ped_Timer *self, PyObject *args, PyObject *kwds) { +- static char *kwlist[] = {"frac", "start", "now", "predicted_end", +- "state_name", NULL}; +- +- self->state_name = NULL; +- + /* XXX: timers aren't really done yet in pyparted */ + PyErr_SetString(PyExc_NotImplementedError, NULL); + return -1; +- +- if (!PyArg_ParseTupleAndKeywords(args, kwds, "|fdddz", kwlist, +- &self->frac, &self->start, &self->now, +- &self->predicted_end, &self->state_name)) { +- return -1; +- } +- +- /* self->state_name now points to the internal buffer of a PyUnicode object, +- * which may be freed when its refcount drops to zero, so strdup it. +- */ +- if (self->state_name) { +- self->state_name = strdup(self->state_name); +- if (!self->state_name) { +- PyErr_NoMemory(); +- return -3; +- } +- } +- +- return 0; + } + + PyObject *_ped_Timer_get(_ped_Timer *self, void *closure) { diff --git a/SPECS/pyparted.spec b/SPECS/pyparted.spec index e15730d..78fc081 100644 --- a/SPECS/pyparted.spec +++ b/SPECS/pyparted.spec @@ -35,14 +35,16 @@ Summary: Python module for GNU parted Name: pyparted Epoch: 1 -Version: 3.11.0 -Release: 13%{?dist} +Version: 3.11.7 +Release: 4%{?dist} License: GPLv2+ Group: System Environment/Libraries URL: https://github.com/rhinstaller/pyparted Source0: https://github.com/rhinstaller/pyparted/archive/%{name}-%{version}.tar.gz +Patch0: pyparted-3.11.7-covscan.patch + BuildRequires: gcc BuildRequires: parted-devel >= 3.2-18 BuildRequires: pkgconfig @@ -91,6 +93,7 @@ partition tables. This package provides Python 3 bindings for parted. %prep %setup -q +%patch0 -p1 %if %{with python2} rm -rf ../%{py2dir} @@ -101,34 +104,34 @@ mv ../%{py2dir} . %build %if %{with python3} -PYTHON=python3 make %{?_smp_mflags} +PYTHON=python3 CFLAGS="%{optflags}" make %{?_smp_mflags} %endif %if %{with python2} pushd %{py2dir} -PYTHON=python2 make %{?_smp_mflags} +PYTHON=python2 CFLAGS="%{optflags}" make %{?_smp_mflags} popd %endif %check %if %{with python3} -PYTHON=python3 make test +PYTHON=python3 CFLAGS="%{optflags}" make test %endif %if %{with python2} pushd %{py2dir} -PYTHON=python2 make test +PYTHON=python2 CFLAGS="%{optflags}" make test popd %endif %install %if %{with python3} -PYTHON=python3 make install DESTDIR=%{buildroot} +PYTHON=python3 CFLAGS="%{optflags}" make install DESTDIR=%{buildroot} %endif %if %{with python2} pushd %{py2dir} -PYTHON=python2 make install DESTDIR=%{buildroot} +PYTHON=python2 CFLAGS="%{optflags}" make install DESTDIR=%{buildroot} popd %endif @@ -149,6 +152,46 @@ popd %endif %changelog +* Mon Jul 12 2021 David Cantrell - 1:3.11.7-4 +- Rebuild for gating + Related: rhbz#1927379 + +* Fri Jul 09 2021 David Cantrell - 1:3.11.7-3 +- More covscan patch followup + Related: rhbz#1927379 + +* Fri Jul 09 2021 David Cantrell - 1:3.11.7-2 +- Patched errors found by covscan + Related: rhbz#1927379 + +* Thu Jul 08 2021 David Cantrell - 1:3.11.7-1 +- Upgrade to pyparted-3.11.7 + Resolves: rhbz#1927379 + +* Tue May 18 2021 David Cantrell - 1:3.11.0-21 +- Rebuild for gating + Related: rhbz#1927379 + +* Tue May 18 2021 David Cantrell - 1:3.11.0-20 +- Fixes for gating + Related: rhbz#1927379 + +* Mon May 17 2021 David Cantrell - 1:3.11.0-19 +- Rebuild for gating + Related: rhbz#1927379 + +* Mon May 17 2021 David Cantrell - 1:3.11.0-18 +- Rebuild for gating + Related: rhbz#1927379 + +* Mon May 17 2021 David Cantrell - 1:3.11.0-17 +- Rebuild + Related: rhbz#1927379 + +* Tue Feb 23 2021 David Cantrell - 1:3.11.0-16 +- Handle PED_EXCEPTION_FIX (Fix/Ignore) exceptions + Resolves: rhbz#1927379 + * Wed Jul 25 2018 David Cantrell - 1:3.11.0-13 - Do not build python2 subpackage Resolves: rhbz#1565329