Test results for the library libupnp-1.3.0 on x86

Summary

Total tests	178
Passed / Failed tests	163 / 15
Warnings	1
Verdict	Test Failed

Problem Summary

Received signal SEGV

Failed Tests (15)

[+] Received signal SEGV (15 problems)

ixml.h, libixml.so.2.0.0
[+] ixmlElement_setAttributeNS ( IXML_Element* element, char* namespaceURI, char* qualifiedName, char* value ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <upnp/ixml.h>

int main(int argc, char *argv[])

{

IXML_Document* doc = 0;

ixmlDocument_createDocumentEx(&doc);

IXML_Element* element = ixmlDocument_createElementNS(doc, "http://ispras.linuxfoundation.org", "qualifiedName");

char value [] = {

'A',

'B',

'C',

'D',

'\0'};

ixmlElement_setAttributeNS(

element,

"http://ispras.linuxfoundation.org",

"qualifiedName",

value); //target call

return 0;

}

FreeList.h, libthreadutil.so.2.0.0
[+] FreeListDestroy ( FreeList* free_list ):int

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <upnp/FreeList.h>

int main(int argc, char *argv[])

{

FreeList free_list;

FreeListAlloc(&free_list);

FreeListDestroy(&free_list); //target call

return 0;

}

ThreadPool.h, libthreadutil.so.2.0.0
[+] TPJobInit ( ThreadPoolJob* job, start_routine func, void* arg ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <stdlib.h>

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

//auxiliary function

void*

func(void* p1){

return malloc(256);

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = 0,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 6,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 7,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 8,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 9,

.idleThreads = 10,

.persistentThreads = 1,

.totalThreads = 2,

.maxThreads = 4,

.currentJobsHQ = 3,

.currentJobsLQ = 4,

.currentJobsMQ = 5}};

ThreadPoolJob job;

ThreadPoolRemove(&tp, 6, &job);

void* arg = malloc(256);

TPJobInit(&job, &func, arg); //target call

return 0;

}

[+] TPJobSetFreeFunction ( ThreadPoolJob* job, free_routine func ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = 0,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 6,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 7,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 8,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 9,

.idleThreads = 10,

.persistentThreads = 1,

.totalThreads = 2,

.maxThreads = 4,

.currentJobsHQ = 3,

.currentJobsLQ = 4,

.currentJobsMQ = 5}};

ThreadPoolJob job;

ThreadPoolRemove(&tp, 6, &job);

TPJobSetFreeFunction(&job, &UpnpFree); //target call

return 0;

}

[+] TPJobSetPriority ( ThreadPoolJob* job, ThreadPriority priority ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = 0,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 6,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 7,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 8,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 9,

.idleThreads = 10,

.persistentThreads = 1,

.totalThreads = 2,

.maxThreads = 4,

.currentJobsHQ = 3,

.currentJobsLQ = 4,

.currentJobsMQ = 5}};

ThreadPoolJob job;

ThreadPoolRemove(&tp, 6, &job);

TPJobSetPriority(&job, LOW_PRIORITY); //target call

return 0;

}

[+] ThreadPoolAdd ( ThreadPool* tp, ThreadPoolJob* job, int* jobId ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <stdlib.h>

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 6, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 7,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 8,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 9,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 10,

.idleThreads = 1,

.persistentThreads = 2,

.totalThreads = 3,

.maxThreads = 4,

.currentJobsHQ = 4,

.currentJobsLQ = 5,

.currentJobsMQ = 6}};

ThreadPoolJob job;

ThreadPoolRemove(&tp, 7, &job);

int* jobId = (int*) malloc(sizeof(int)*256);

ThreadPoolAdd(&tp, &job, jobId); //target call

return 0;

}

[+] ThreadPoolAddPersistent ( ThreadPool* tp, ThreadPoolJob* job, int* jobId ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <stdlib.h>

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 6, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 7,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 8,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 9,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 10,

.idleThreads = 1,

.persistentThreads = 2,

.totalThreads = 3,

.maxThreads = 4,

.currentJobsHQ = 4,

.currentJobsLQ = 5,

.currentJobsMQ = 6}};

ThreadPoolJob job;

ThreadPoolRemove(&tp, 7, &job);

int* jobId = (int*) malloc(sizeof(int)*256);

ThreadPoolAddPersistent(&tp, &job, jobId); //target call

return 0;

}

[+] ThreadPoolRemove ( ThreadPool* tp, int jobId, ThreadPoolJob* out ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <upnp/TimerThread.h>

#include <upnp/upnp.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

TimerThread timer = {

.mutex = mutex,

.condition = condition,

.lastEventId = 6,

.eventQ = lowJobQ,

.shutdown = 7,

.freeEvents = jobFreeList,

.tp = 0};

ThreadPoolJob persistentJob;

TimerThreadRemove(&timer, 8, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 9,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 10,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 1,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 2,

.idleThreads = 3,

.persistentThreads = 4,

.totalThreads = 5,

.maxThreads = 4,

.currentJobsHQ = 6,

.currentJobsLQ = 7,

.currentJobsMQ = 8}};

ThreadPoolJob out;

ThreadPoolRemove(&tp, 9, &out); //target call

return 0;

}

[+] ThreadPoolShutdown ( ThreadPool* tp ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <upnp/upnp.h>

#include <upnp/ThreadPool.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 5;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

FreeList jobFreeList;

FreeListAlloc(&jobFreeList);

LinkedList lowJobQ;

ListInit(&lowJobQ, &cmp_func, &UpnpFree);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 6, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 1,

.shutdown = 2,

.totalThreads = 3,

.persistentThreads = 4,

.jobFreeList = jobFreeList,

.lowJobQ = lowJobQ,

.medJobQ = lowJobQ,

.highJobQ = lowJobQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 7,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 8,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 9,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 10,

.idleThreads = 1,

.persistentThreads = 2,

.totalThreads = 3,

.maxThreads = 4,

.currentJobsHQ = 4,

.currentJobsLQ = 5,

.currentJobsMQ = 6}};

ThreadPoolShutdown(&tp); //target call

return 0;

}

TimerThread.h, libthreadutil.so.2.0.0
[+] TimerThreadInit ( TimerThread* timer, ThreadPool* tp ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <upnp/upnp.h>

#include <upnp/TimerThread.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 2;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

LinkedList eventQ;

ListInit(&eventQ, &cmp_func, &UpnpFree);

FreeList freeEvents;

FreeListAlloc(&freeEvents);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 8, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 4,

.shutdown = 5,

.totalThreads = 6,

.persistentThreads = 7,

.jobFreeList = freeEvents,

.lowJobQ = eventQ,

.medJobQ = eventQ,

.highJobQ = eventQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 9,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 10,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 1,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 2,

.idleThreads = 3,

.persistentThreads = 4,

.totalThreads = 5,

.maxThreads = 4,

.currentJobsHQ = 6,

.currentJobsLQ = 7,

.currentJobsMQ = 8}};

TimerThread timer = {

.mutex = mutex,

.condition = condition,

.lastEventId = 1,

.eventQ = eventQ,

.shutdown = 3,

.freeEvents = freeEvents,

.tp = &tp};

TimerThreadInit(&timer, &tp); //target call

return 0;

}

[+] TimerThreadSchedule ( TimerThread* timer, time_t time, TimeoutType type, ThreadPoolJob* job, Duration duration, int* id ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <stdlib.h>

#include <upnp/upnp.h>

#include <upnp/TimerThread.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 2;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

LinkedList eventQ;

ListInit(&eventQ, &cmp_func, &UpnpFree);

FreeList freeEvents;

FreeListAlloc(&freeEvents);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 8, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 4,

.shutdown = 5,

.totalThreads = 6,

.persistentThreads = 7,

.jobFreeList = freeEvents,

.lowJobQ = eventQ,

.medJobQ = eventQ,

.highJobQ = eventQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 9,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 10,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 1,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 2,

.idleThreads = 3,

.persistentThreads = 4,

.totalThreads = 5,

.maxThreads = 4,

.currentJobsHQ = 6,

.currentJobsLQ = 7,

.currentJobsMQ = 8}};

TimerThread timer = {

.mutex = mutex,

.condition = condition,

.lastEventId = 1,

.eventQ = eventQ,

.shutdown = 3,

.freeEvents = freeEvents,

.tp = &tp};

struct tm* __tp = getdate("__string");

time_t time_1 = mktime(__tp);

ThreadPoolJob job;

ThreadPoolRemove(&tp, 9, &job);

int* id = (int*) malloc(sizeof(int)*256);

TimerThreadSchedule(

&timer,

time_1,

ABS_SEC,

&job,

SHORT_TERM,

id); //target call

return 0;

}

[+] TimerThreadShutdown ( TimerThread* timer ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <upnp/upnp.h>

#include <upnp/TimerThread.h>

//auxiliary function

int

cmp_func(void* p1, void* p2){

return 2;

}

int main(int argc, char *argv[])

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t mutex;

pthread_mutex_init(&mutex, &__mutexattr);

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t condition;

pthread_cond_init(&condition, &__cond_attr);

LinkedList eventQ;

ListInit(&eventQ, &cmp_func, &UpnpFree);

FreeList freeEvents;

FreeListAlloc(&freeEvents);

ThreadPoolJob persistentJob;

ThreadPoolRemove(0, 8, &persistentJob);

ThreadPoolAttr attr;

TPAttrInit(&attr);

ThreadPool tp = {

.mutex = mutex,

.condition = condition,

.start_and_shutdown = condition,

.lastJobId = 4,

.shutdown = 5,

.totalThreads = 6,

.persistentThreads = 7,

.jobFreeList = freeEvents,

.lowJobQ = eventQ,

.medJobQ = eventQ,

.highJobQ = eventQ,

.persistentJob = &persistentJob,

.attr = attr,

.stats = (ThreadPoolStats) {

.totalTimeHQ = 1.5,

.totalJobsHQ = 9,

.avgWaitHQ = 2.5,

.totalTimeMQ = 3.5,

.totalJobsMQ = 10,

.avgWaitMQ = 4.5,

.totalTimeLQ = 5.5,

.totalJobsLQ = 1,

.avgWaitLQ = 6.5,

.totalWorkTime = 7.5,

.totalIdleTime = 8.5,

.workerThreads = 2,

.idleThreads = 3,

.persistentThreads = 4,

.totalThreads = 5,

.maxThreads = 4,

.currentJobsHQ = 6,

.currentJobsLQ = 7,

.currentJobsMQ = 8}};

TimerThread timer = {

.mutex = mutex,

.condition = condition,

.lastEventId = 1,

.eventQ = eventQ,

.shutdown = 3,

.freeEvents = freeEvents,

.tp = &tp};

TimerThreadShutdown(&timer); //target call

return 0;

}

upnptools.h, libupnp.so.2.0.0
[+] UpnpMakeAction ( char const* ActionName, char const* ServType, int NumArg, char const* Arg, ... ):IXML_Document*

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <upnp/upnptools.h>

int main(int argc, char *argv[])

{

UpnpMakeAction(

"ActionName",

"ServType",

"Arg",

0); //target call

return 0;

}

[+] UpnpMakeActionResponse ( char const* ActionName, char const* ServType, int NumArg, char const* Arg, ... ):IXML_Document*

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <upnp/upnptools.h>

int main(int argc, char *argv[])

{

UpnpMakeActionResponse(

"ActionName",

"ServType",

"Arg",

0); //target call

return 0;

}

[+] UpnpResolveURL ( char const* BaseURL, char const* RelURL, char* AbsURL ):int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <upnp/upnptools.h>

int main(int argc, char *argv[])

{

char AbsURL [] = {

'A',

'B',

'C',

'D',

'\0'};

UpnpResolveURL(

"http://ispras.linuxfoundation.org",

AbsURL); //target call

return 0;

}

to the top

Warnings (1)

[+] Received signal ABRT (1 warning)

iasnprintf.h, libthreadutil.so.2.0.0
[+] iasnprintfFree ( char* p1 ):void

received signal ABRT

*** glibc detected *** ./test: munmap_chunk(): invalid pointer: 0xbff0ca5b ***
======= Backtrace: =========
/lib/libc.so.6[0xb76bf50b]
/lib/libc.so.6[0xb76c07f6]
/home/andrey/upstream-tracker/testing/libupnp/1.3.0/lib/libthreadutil.so.2(iasnprintfFree+0x1a)[0xb77df2ea]
./test[0x8048542]
/lib/libc.so.6(__libc_start_main+0xfe)[0xb7668ace]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:02 4623202    /home/andrey/upstream-tracker/tests/libupnp/1.3.0/groups/iasnprintf/functions/iasnprintfFree/test
08049000-0804a000 r--p 00000000 08:02 4623202    /home/andrey/upstream-tracker/tests/libupnp/1.3.0/groups/iasnprintf/functions/iasnprintfFree/test
0804a000-0804b000 rw-p 00001000 08:02 4623202    /home/andrey/upstream-tracker/tests/libupnp/1.3.0/groups/iasnprintf/functions/iasnprintfFree/test
0804b000-0806c000 rw-p 00000000 00:00 0          [heap]
b7616000-b7634000 r-xp 00000000 08:01 17033      /lib/libgcc_s.so.1
b7634000-b7635000 r--p 0001d000 08:01 17033      /lib/libgcc_s.so.1
b7635000-b7636000 rw-p 0001e000 08:01 17033      /lib/libgcc_s.so.1
b7636000-b7638000 rw-p 00000000 00:00 0
b7638000-b764e000 r-xp 00000000 08:01 16822      /lib/libpthread-2.10.1.so
b764e000-b764f0 ...

1
2
3
4
5
6
7
8
9
10
11
12

#include <upnp/iasnprintf.h>

int main(int argc, char *argv[])

{

char p1 [] = {

'A',

'B',

'C',

'D',

'\0'};

iasnprintfFree(p1); //target call

return 0;

}

to the top